Class SQLCollection

packages/core/src/database/sql-collection.ts:68–374

export const MAX_SQL_PARAMETERS = 200;

export class SQLCollection<
  TCollectionType extends keyof DatabaseSchema,
  T extends DatabaseSchema[TCollectionType] = DatabaseSchema[TCollectionType]
> implements DatabaseCollection<SQLiteItem<T>, true>
{
  constructor(
    private readonly db: DatabaseAccessor,
    _startTransaction: (
      executor: (tr: Kysely<DatabaseSchema>) => Promise<void>
    ) => Promise<void>,
    public readonly type: TCollectionType,
    private readonly eventManager: EventManager,
    private readonly sanitizer: Sanitizer
  ) {}

  async clear() {
    await this.db().deleteFrom(this.type).execute();
  }

  async init() {}

  async upsert(item: SQLiteItem<T>) {
    if (!item.id) throw new Error("The item must contain the id field.");
    if (!item.deleted) item.dateCreated = item.dateCreated || Date.now();

    // if item is newly synced, remote will be true.
    if (!item.remote) {
      item.dateModified = Date.now();
      item.synced = false;
    }
    // the item has become local now, so remove the flags
    delete item.remote;

    if (!this.sanitizer.sanitize(this.type, item)) return;

    await this.db()
      .replaceInto<keyof DatabaseSchema>(this.type)
      .values(item)
      .execute();

    this.eventManager.publish(EVENTS.databaseUpdated, <UpsertEvent>{
      type: "upsert",
      collection: this.type,
      item
    });
  }

  async softDelete(ids: string[]) {
    await this.db()
      .transaction()
      .execute(async (tx) => {
        for (const chunk of toChunks(ids, MAX_SQL_PARAMETERS)) {
          await tx
            .replaceInto<keyof DatabaseSchema>(this.type)
            .values(
              chunk.map((id) => ({
                id,
                deleted: true,