@powersync/service-module-mongodb-storage 0.0.0-dev-20260602073133 → 0.0.0-dev-20260803144812

package/src/storage/implementation/MongoPersistedSyncRules.ts

@@ -1,82 +0,0 @@
-import * as sqlite from 'node:sqlite';
-
-import { ServiceAssertionError } from '@powersync/lib-services-framework';
-import { storage } from '@powersync/service-core';
-import {
-  BucketDataScope,
-  BucketDataSource,
-  CompatibilityOption,
-  DEFAULT_HYDRATION_STATE,
-  HydratedSyncConfig,
-  HydrationState,
-  nodeSqlite,
-  ParameterIndexLookupCreator,
-  ParameterLookupScope,
-  SyncConfigWithErrors,
-  versionedHydrationState
-} from '@powersync/service-sync-rules';
-import { BucketDefinitionMapping } from './BucketDefinitionMapping.js';
-import { StorageConfig } from './models.js';
-
-export class MongoPersistedSyncRules implements storage.PersistedSyncRules {
-  public readonly hydrationState: HydrationState;
-
-  constructor(
-    public readonly id: number,
-    public readonly syncConfigWithErrors: SyncConfigWithErrors,
-    public readonly slot_name: string,
-    private readonly mapping: BucketDefinitionMapping | null,
-    private readonly storageConfig: StorageConfig
-  ) {
-    if (this.storageConfig.incrementalReprocessing) {
-      if (this.mapping == null) {
-        throw new ServiceAssertionError(`mapping is required for v3 storage`);
-      }
-      this.hydrationState = new MongoHydrationState(this.mapping, this.id);
-    } else if (
-      !this.syncConfigWithErrors.config.compatibility.isEnabled(CompatibilityOption.versionedBucketIds) &&
-      !this.storageConfig.versionedBuckets
-    ) {
-      this.hydrationState = DEFAULT_HYDRATION_STATE;
-    } else {
-      this.hydrationState = versionedHydrationState(this.id);
-    }
-  }
-
-  hydratedSyncConfig(): HydratedSyncConfig {
-    return this.syncConfigWithErrors.config.hydrate({
-      hydrationState: this.hydrationState,
-      sqlite: nodeSqlite(sqlite)
-    });
-  }
-}
-
-class MongoHydrationState implements HydrationState {
-  constructor(
-    private readonly mapping: BucketDefinitionMapping,
-    private readonly version: number
-  ) {}
-
-  getBucketSourceScope(source: BucketDataSource): BucketDataScope {
-    // Keep this aligned with versionedHydrationState() for now.
-    //
-    // Previous Mongo-specific behavior:
-    // return {
-    //   bucketPrefix: defId,
-    //   source
-    // };
-    return {
-      bucketPrefix: `${this.version}#${source.uniqueName}`,
-      source
-    };
-  }
-
-  getParameterIndexLookupScope(source: ParameterIndexLookupCreator): ParameterLookupScope {
-    const defId = this.mapping.parameterLookupId(source);
-    return {
-      lookupName: defId,
-      queryId: '',
-      source
-    };
-  }
-}

package/src/storage/implementation/MongoPersistedSyncRulesContent.ts

@@ -1,101 +0,0 @@
-import { mongo } from '@powersync/lib-service-mongodb';
-import { ServiceAssertionError } from '@powersync/lib-services-framework';
-import { storage, SyncRuleState } from '@powersync/service-core';
-import * as bson from 'bson';
-import { ReplicationStreamDocumentV3, SyncConfigDefinition } from '../storage-index.js';
-import { BucketDefinitionMapping } from './BucketDefinitionMapping.js';
-import { MongoPersistedSyncRules } from './MongoPersistedSyncRules.js';
-import { MongoSyncRulesLock } from './MongoSyncRulesLock.js';
-import { PowerSyncMongo } from './db.js';
-import { getMongoStorageConfig } from './models.js';
-import { SyncRuleDocumentV1 } from './v1/models.js';
-
-abstract class MongoPersistedSyncRulesContentBase extends storage.PersistedSyncRulesContent {
-  public current_lock: MongoSyncRulesLock | null = null;
-  public readonly mapping: BucketDefinitionMapping;
-  public readonly syncConfigId: bson.ObjectId | null;
-
-  protected constructor(
-    protected readonly db: PowerSyncMongo,
-    options: ConstructorParameters<typeof storage.PersistedSyncRulesContent>[0] & {
-      mapping: BucketDefinitionMapping;
-      syncConfigId: bson.ObjectId | null;
-    }
-  ) {
-    const { mapping, syncConfigId, ...base } = options;
-    super(base);
-    this.mapping = mapping;
-    this.syncConfigId = syncConfigId;
-  }
-
-  getStorageConfig() {
-    return getMongoStorageConfig(this.storageVersion);
-  }
-
-  parsed(options: storage.ParseSyncRulesOptions): storage.PersistedSyncRules {
-    const parsed = super.parsed(options);
-    const storageConfig = this.getStorageConfig();
-
-    return new MongoPersistedSyncRules(
-      parsed.id,
-      parsed.syncConfigWithErrors,
-      parsed.slot_name,
-      storageConfig.incrementalReprocessing ? this.mapping : null,
-      storageConfig
-    );
-  }
-
-  async lock(session?: mongo.ClientSession) {
-    const lock = await MongoSyncRulesLock.createLock(this.db.versioned(this.getStorageConfig()), this, session);
-    this.current_lock = lock;
-    return lock;
-  }
-}
-
-export class MongoPersistedSyncRulesContentV1 extends MongoPersistedSyncRulesContentBase {
-  constructor(db: PowerSyncMongo, doc: SyncRuleDocumentV1) {
-    super(db, {
-      id: doc._id,
-      sync_rules_content: doc.content,
-      compiled_plan: doc.serialized_plan ?? null,
-      last_checkpoint_lsn: doc.last_checkpoint_lsn,
-      // Handle legacy values
-      slot_name: doc.slot_name ?? `powersync_${doc._id}`,
-      last_fatal_error: doc.last_fatal_error,
-      last_fatal_error_ts: doc.last_fatal_error_ts,
-      last_checkpoint_ts: doc.last_checkpoint_ts,
-      last_keepalive_ts: doc.last_keepalive_ts,
-      active: doc.state == SyncRuleState.ACTIVE,
-      storageVersion: doc.storage_version ?? storage.LEGACY_STORAGE_VERSION,
-      mapping: new BucketDefinitionMapping(),
-      syncConfigId: null
-    });
-  }
-}
-
-export class MongoPersistedSyncRulesContentV3 extends MongoPersistedSyncRulesContentBase {
-  declare public readonly syncConfigId: bson.ObjectId;
-
-  constructor(db: PowerSyncMongo, doc: ReplicationStreamDocumentV3, config: SyncConfigDefinition) {
-    const state = doc.sync_configs.find((c) => c._id.equals(config._id));
-    if (state == null) {
-      throw new ServiceAssertionError(`Cannot find sync config ${config._id} in replication stream ${doc._id}`);
-    }
-    super(db, {
-      id: doc._id,
-      sync_rules_content: config.content,
-      compiled_plan: config.serialized_plan ?? null,
-
-      last_checkpoint_lsn: state?.last_checkpoint_lsn ?? null,
-      slot_name: doc.slot_name ?? `powersync_${doc._id}`,
-      last_fatal_error: doc.last_fatal_error,
-      last_fatal_error_ts: doc.last_fatal_error_ts,
-      last_checkpoint_ts: doc.last_checkpoint_ts,
-      last_keepalive_ts: doc.last_keepalive_ts,
-      active: doc.state == SyncRuleState.ACTIVE && state.state == SyncRuleState.ACTIVE,
-      storageVersion: doc.storage_version,
-      mapping: BucketDefinitionMapping.fromSyncConfig(config),
-      syncConfigId: config._id
-    });
-  }
-}

package/src/storage/implementation/common/MongoSyncBucketStorageContext.ts

@@ -1,15 +0,0 @@
-import { InternalOpId } from '@powersync/service-core';
-import * as bson from 'bson';
-import { BucketDefinitionMapping } from '../BucketDefinitionMapping.js';
-import type { VersionedPowerSyncMongo } from '../db.js';
-
-export interface MongoSyncBucketStorageContext<TDb extends VersionedPowerSyncMongo = VersionedPowerSyncMongo> {
-  db: TDb;
-  group_id: number;
-  mapping: BucketDefinitionMapping;
-}
-
-export interface MongoSyncBucketStorageCheckpoint {
-  checkpoint: InternalOpId;
-  snapshotTime: bson.Timestamp;
-}

package/src/storage/implementation/common/SingleBucketStore.ts

@@ -1,63 +0,0 @@
-import { mongo } from '@powersync/lib-service-mongodb';
-import { InternalOpId } from '@powersync/service-core';
-import { BucketDataProperties } from '../models.js';
-import { BucketDataDoc, BucketKey } from './BucketDataDoc.js';
-
-const GENERIC_ID = Symbol('BucketDataDocumentGenericId');
-export type BucketDataDocumentGenericId = {
-  b: string;
-  o: InternalOpId;
-  // Hack to ensure this can't be constructed directly
-  [GENERIC_ID]: true;
-};
-
-/**
- * This document is never actually constructed - we use it as a "virtual" type.
- *
- * The actual implementations are BucketDataDocumentV1 or BucketDataDocumentV3.
- * They don't fully satisfy this interface, but this works to share common implementations.
- *
- * The idea is that we can have a common implementation between V1 & V3, using this type,
- * and operate on MongoDB collections.
- *
- * This interface serves two primary purposes:
- * 1. Captures properties that exist on both V1 and V3 storage models.
- * 2. Gives a common reference when querying or modifying collections.
- *
- * Generics would've been ideal, but they don't play well with MongoDB collections.
- */
-export interface BucketDataDocumentGeneric extends BucketDataProperties {
-  _id: BucketDataDocumentGenericId;
-}
-
-/**
- * Represent read/write access for a single bucket.
- *
- * This does not implement the actual collection operations, but supports the required conversions
- * between in-memory BucketDataDoc and the specific storage formats.
- */
-export interface SingleBucketStore {
-  readonly key: BucketKey;
-
-  readonly collection: mongo.Collection<BucketDataDocumentGeneric>;
-  docId(o: InternalOpId): BucketDataDocumentGenericId;
-  readonly minId: BucketDataDocumentGenericId;
-  readonly maxId: BucketDataDocumentGenericId;
-
-  /**
-   * Convert in-memory document -> persisted document.
-   */
-  toPersistedDocument(source: Omit<BucketDataDoc, 'bucketKey'>): BucketDataDocumentGeneric;
-
-  /**
-   * Convert persisted document -> in-memory document.
-   */
-  fromPersistedDocument(doc: BucketDataDocumentGeneric): BucketDataDoc;
-
-  /**
-   * Convert partial persisted document -> partial in-memory document.
-   */
-  fromPartialPersistedDocument<T extends keyof BucketDataProperties>(
-    doc: Pick<BucketDataDocumentGeneric, '_id' | T>
-  ): Pick<BucketDataDoc, 'bucketKey' | 'o' | T>;
-}

package/src/storage/implementation/v3/MongoParameterCompactorV3.ts

@@ -1,24 +0,0 @@
-import { mongo } from '@powersync/lib-service-mongodb';
-import { MongoParameterCompactor } from '../MongoParameterCompactor.js';
-import { VersionedPowerSyncMongoV3 } from './VersionedPowerSyncMongoV3.js';
-
-export class MongoParameterCompactorV3 extends MongoParameterCompactor {
-  declare protected readonly db: VersionedPowerSyncMongoV3;
-
-  protected async getCollections(): Promise<mongo.Collection<mongo.Document>[]> {
-    const collections = await this.db.listParameterIndexCollectionsV3(this.group_id);
-    return collections.map((collection) => collection.collection as unknown as mongo.Collection<mongo.Document>);
-  }
-
-  protected collectionFilter(): mongo.Document {
-    return {};
-  }
-
-  protected deleteFilter(doc: mongo.Document): mongo.Document {
-    return {
-      lookup: doc.lookup,
-      _id: { $lte: doc._id },
-      key: doc.key
-    };
-  }
-}

package/src/storage/implementation/v3/MongoParameterLookupV3.ts

@@ -1,11 +0,0 @@
-import { deserializeParameterLookup } from '@powersync/service-core';
-import { ParameterIndexId, ScopedParameterLookup, SqliteJsonValue } from '@powersync/service-sync-rules';
-import * as bson from 'bson';
-
-export function serializeParameterLookupV3(lookup: ScopedParameterLookup): bson.Binary {
-  return new bson.Binary(bson.serialize({ l: lookup.values.slice(2) }));
-}
-
-export function deserializeParameterLookupV3(lookup: bson.Binary, indexId: ParameterIndexId): SqliteJsonValue[] {
-  return [indexId, '', ...deserializeParameterLookup(lookup)];
-}

package/src/storage/implementation/v3/SingleBucketStoreV3.ts

@@ -1,68 +0,0 @@
-import { mongo } from '@powersync/lib-service-mongodb';
-import { InternalOpId } from '@powersync/service-core';
-import { BucketDataDoc, BucketKey } from '../common/BucketDataDoc.js';
-import {
-  BucketDataDocumentGeneric,
-  BucketDataDocumentGenericId,
-  SingleBucketStore
-} from '../common/SingleBucketStore.js';
-import { BucketDataProperties } from '../models.js';
-import { VersionedPowerSyncMongoV3 } from './VersionedPowerSyncMongoV3.js';
-import { BucketDataDocumentV3, BucketDataKeyV3, loadBucketDataDocumentV3, serializeBucketDataV3 } from './models.js';
-
-export class SingleBucketStoreV3 implements SingleBucketStore {
-  public readonly collection: mongo.Collection<BucketDataDocumentGeneric>;
-
-  constructor(
-    private db: VersionedPowerSyncMongoV3,
-    public readonly key: BucketKey
-  ) {
-    this.collection = db.bucketDataV3(
-      key.replicationStreamId,
-      key.definitionId
-    ) as unknown as mongo.Collection<BucketDataDocumentGeneric>;
-  }
-
-  docId(o: InternalOpId): BucketDataDocumentGenericId {
-    // `satisfies BucketDataKeyV3` checks that we use the correct type for V3 storage
-    // `as BucketDataDocumentGenericId` does a cast to get the interface virtual type
-    return {
-      b: this.key.bucket,
-      o
-    } satisfies BucketDataKeyV3 as BucketDataDocumentGenericId;
-  }
-
-  get minId(): BucketDataDocumentGenericId {
-    return {
-      b: this.key.bucket,
-      o: new mongo.MinKey()
-    } as any; // No way to properly type this
-  }
-
-  get maxId(): BucketDataDocumentGenericId {
-    return {
-      b: this.key.bucket,
-      o: new mongo.MaxKey()
-    } as any; // No way to properly type this
-  }
-
-  toPersistedDocument(source: Omit<BucketDataDoc, 'bucketKey'>): BucketDataDocumentGeneric {
-    return serializeBucketDataV3({ bucketKey: this.key, ...source }) as BucketDataDocumentGeneric;
-  }
-
-  fromPersistedDocument(doc: BucketDataDocumentGeneric): BucketDataDoc {
-    return loadBucketDataDocumentV3(this.key, doc as BucketDataDocumentV3);
-  }
-
-  fromPartialPersistedDocument<T extends keyof BucketDataProperties>(
-    doc: Pick<BucketDataDocumentGeneric, '_id' | T>
-  ): Pick<BucketDataDoc, 'bucketKey' | 'o' | T> {
-    const document = doc as Pick<BucketDataDocumentV3, '_id' | T>;
-    const { _id, ...rest } = document;
-    return {
-      bucketKey: this.key,
-      o: _id.o,
-      ...rest
-    } as Pick<BucketDataDoc, 'bucketKey' | 'o' | T>;
-  }
-}