@powersync/service-module-postgres-storage 0.0.0-dev-20250116115804

package/dist/@types/types/models/SyncRules.d.ts

@@ -0,0 +1,47 @@
+import { storage } from '@powersync/service-core';
+import * as t from 'ts-codec';
+export declare const SyncRules: t.ObjectCodec<{
+    id: t.Codec<number, number, "pg_number", t.CodecProps>;
+    state: t.EnumCodec<typeof storage.SyncRuleState>;
+    /**
+     * True if initial snapshot has been replicated.
+     *
+     * Can only be false if state == PROCESSING.
+     */
+    snapshot_done: t.IdentityCodec<t.CodecType.Boolean>;
+    /**
+     * The last consistent checkpoint.
+     *
+     * There may be higher OpIds used in the database if we're in the middle of replicating a large transaction.
+     */
+    last_checkpoint: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+    /**
+     * The LSN associated with the last consistent checkpoint.
+     */
+    last_checkpoint_lsn: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+    /**
+     * If set, no new checkpoints may be created < this value.
+     */
+    no_checkpoint_before: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+    slot_name: t.IdentityCodec<t.CodecType.String>;
+    /**
+     * Last time we persisted a checkpoint.
+     *
+     * This may be old if no data is incoming.
+     */
+    last_checkpoint_ts: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Date, string, string, t.CodecProps>>;
+    /**
+     * Last time we persisted a checkpoint or keepalive.
+     *
+     * This should stay fairly current while replicating.
+     */
+    last_keepalive_ts: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<Date, string, string, t.CodecProps>>;
+    /**
+     * If an error is stopping replication, it will be stored here.
+     */
+    last_fatal_error: t.Union<t.Codec<null, null, string, t.CodecProps>, t.IdentityCodec<t.CodecType.String>>;
+    keepalive_op: t.Union<t.Codec<null, null, string, t.CodecProps>, t.Codec<bigint, string | number, string, t.CodecProps>>;
+    content: t.IdentityCodec<t.CodecType.String>;
+}>;
+export type SyncRules = t.Encoded<typeof SyncRules>;
+export type SyncRulesDecoded = t.Decoded<typeof SyncRules>;

package/dist/@types/types/models/WriteCheckpoint.d.ts

@@ -0,0 +1,15 @@
+import * as t from 'ts-codec';
+export declare const WriteCheckpoint: t.ObjectCodec<{
+    user_id: t.IdentityCodec<t.CodecType.String>;
+    lsns: t.Codec<Record<string, string>, string, string, t.CodecProps>;
+    write_checkpoint: t.Codec<bigint, string | number, string, t.CodecProps>;
+}>;
+export type WriteCheckpoint = t.Encoded<typeof WriteCheckpoint>;
+export type WriteCheckpointDecoded = t.Decoded<typeof WriteCheckpoint>;
+export declare const CustomWriteCheckpoint: t.ObjectCodec<{
+    user_id: t.IdentityCodec<t.CodecType.String>;
+    write_checkpoint: t.Codec<bigint, string | number, string, t.CodecProps>;
+    sync_rules_id: t.Codec<bigint, string | number, string, t.CodecProps>;
+}>;
+export type CustomWriteCheckpoint = t.Encoded<typeof CustomWriteCheckpoint>;
+export type CustomWriteCheckpointDecoded = t.Decoded<typeof CustomWriteCheckpoint>;

package/dist/@types/types/models/models-index.d.ts

@@ -0,0 +1,10 @@
+export * from './ActiveCheckpoint.js';
+export * from './ActiveCheckpointNotification.js';
+export * from './BucketData.js';
+export * from './BucketParameters.js';
+export * from './CurrentData.js';
+export * from './Instance.js';
+export * from './Migration.js';
+export * from './SourceTable.js';
+export * from './SyncRules.js';
+export * from './WriteCheckpoint.js';

package/dist/@types/types/types.d.ts

@@ -0,0 +1,96 @@
+import * as pg_wire from '@powersync/service-jpgwire';
+import { configFile } from '@powersync/service-types';
+import * as t from 'ts-codec';
+export * as models from './models/models-index.js';
+export declare const MAX_BATCH_RECORD_COUNT = 2000;
+export declare const MAX_BATCH_ESTIMATED_SIZE = 5000000;
+export declare const MAX_BATCH_CURRENT_DATA_SIZE = 50000000;
+export declare const BatchLimits: t.ObjectCodec<{
+    /**
+     * Maximum size of operations we write in a single transaction.
+     */
+    max_estimated_size: t.OptionalCodec<t.Codec<number, number, string, t.CodecProps>>;
+    /**
+     * Limit number of documents to write in a single transaction.
+     */
+    max_record_count: t.OptionalCodec<t.Codec<number, number, string, t.CodecProps>>;
+}>;
+export type BatchLimits = t.Encoded<typeof BatchLimits>;
+export declare const OperationBatchLimits: t.Intersection<t.Codec<{
+    max_estimated_size?: number | undefined;
+    max_record_count?: number | undefined;
+}, {
+    max_estimated_size?: number | undefined;
+    max_record_count?: number | undefined;
+}, string, t.CodecProps>, t.ObjectCodec<{
+    /**
+     * Maximum size of size of current_data documents we lookup at a time.
+     */
+    max_current_data_batch_size: t.OptionalCodec<t.Codec<number, number, string, t.CodecProps>>;
+}>>;
+export type OperationBatchLimits = t.Encoded<typeof OperationBatchLimits>;
+export declare const PostgresStorageConfig: t.Intersection<t.Codec<{
+    type: string;
+} & {
+    type: "postgresql";
+    id?: string | undefined;
+    tag?: string | undefined;
+    uri?: string | undefined;
+    hostname?: string | undefined;
+    port?: number | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    sslmode?: "verify-full" | "verify-ca" | "disable" | undefined;
+    cacert?: string | undefined;
+    client_certificate?: string | undefined;
+    client_private_key?: string | undefined;
+    tls_servername?: string | undefined;
+    reject_ip_ranges?: string[] | undefined;
+    slot_name_prefix?: string | undefined;
+}, {
+    type: string;
+} & {
+    type: "postgresql";
+    id?: string | undefined;
+    tag?: string | undefined;
+    uri?: string | undefined;
+    hostname?: string | undefined;
+    port?: string | number | undefined;
+    username?: string | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    sslmode?: "verify-full" | "verify-ca" | "disable" | undefined;
+    cacert?: string | undefined;
+    client_certificate?: string | undefined;
+    client_private_key?: string | undefined;
+    tls_servername?: string | undefined;
+    reject_ip_ranges?: string[] | undefined;
+    slot_name_prefix?: string | undefined;
+}, string, t.CodecProps>, t.ObjectCodec<{
+    /**
+     * Allow batch operation limits to be configurable.
+     * Postgres has less batch size restrictions compared to MongoDB.
+     * Increasing limits can drastically improve replication performance, but
+     * can come at the cost of higher memory usage or potential issues.
+     */
+    batch_limits: t.OptionalCodec<t.Codec<{
+        max_estimated_size?: number | undefined;
+        max_record_count?: number | undefined;
+    } & {
+        max_current_data_batch_size?: number | undefined;
+    }, {
+        max_estimated_size?: number | undefined;
+        max_record_count?: number | undefined;
+    } & {
+        max_current_data_batch_size?: number | undefined;
+    }, string, t.CodecProps>>;
+}>>;
+export type PostgresStorageConfig = t.Encoded<typeof PostgresStorageConfig>;
+export type PostgresStorageConfigDecoded = t.Decoded<typeof PostgresStorageConfig>;
+export type RequiredOperationBatchLimits = Required<OperationBatchLimits>;
+export type NormalizedPostgresStorageConfig = pg_wire.NormalizedConnectionConfig & {
+    batch_limits: RequiredOperationBatchLimits;
+};
+export declare const normalizePostgresStorageConfig: (baseConfig: PostgresStorageConfigDecoded) => NormalizedPostgresStorageConfig;
+export declare const isPostgresStorageConfig: (config: configFile.BaseStorageConfig) => config is PostgresStorageConfig;

package/dist/@types/utils/bson.d.ts

@@ -0,0 +1,6 @@
+import { storage } from '@powersync/service-core';
+/**
+ * BSON is used to serialize certain documents for storage in BYTEA columns.
+ * JSONB columns do not directly support storing binary data which could be required in future.
+ */
+export declare function replicaIdToSubkey(tableId: string, id: storage.ReplicaId): string;

package/dist/@types/utils/bucket-data.d.ts

@@ -0,0 +1,18 @@
+import { models } from '../types/types.js';
+export declare const mapOpEntry: (entry: models.BucketDataDecoded) => {
+    op_id: string;
+    op: models.OpType;
+    object_type: string | undefined;
+    object_id: string | undefined;
+    checksum: number;
+    subkey: string;
+    data: string | null;
+} | {
+    op_id: string;
+    op: models.OpType;
+    checksum: number;
+    object_type?: undefined;
+    object_id?: undefined;
+    subkey?: undefined;
+    data?: undefined;
+};

package/dist/@types/utils/db.d.ts

@@ -0,0 +1,8 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+export declare const STORAGE_SCHEMA_NAME = "powersync";
+export declare const NOTIFICATION_CHANNEL = "powersynccheckpoints";
+/**
+ * Re export for prettier to detect the tag better
+ */
+export declare const sql: (strings: TemplateStringsArray, ...params: import("@powersync/service-jpgwire").StatementParam[]) => import("@powersync/service-jpgwire").Statement;
+export declare const dropTables: (client: lib_postgres.DatabaseClient) => Promise<void>;

package/dist/@types/utils/ts-codec.d.ts

@@ -0,0 +1,5 @@
+import * as t from 'ts-codec';
+/**
+ * Returns a new codec with a subset of keys. Equivalent to the TypeScript Pick utility.
+ */
+export declare const pick: <T extends t.AnyObjectCodecShape, Keys extends keyof T>(codec: t.ObjectCodec<T>, keys: Keys[]) => t.ObjectCodec<Pick<T, Keys>>;

package/dist/@types/utils/utils-index.d.ts

@@ -0,0 +1,4 @@
+export * from './bson.js';
+export * from './bucket-data.js';
+export * from './db.js';
+export * from './ts-codec.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './module/PostgresStorageModule.js';
+export * from './migrations/PostgresMigrationAgent.js';
+export * from './utils/utils-index.js';
+export * as utils from './utils/utils-index.js';
+export * from './storage/storage-index.js';
+export * as storage from './storage/storage-index.js';
+export * from './types/types.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAElD,cAAc,wCAAwC,CAAC;AAEvD,cAAc,wBAAwB,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,wBAAwB,CAAC;AAEhD,cAAc,4BAA4B,CAAC;AAC3C,OAAO,KAAK,OAAO,MAAM,4BAA4B,CAAC;AACtD,cAAc,kBAAkB,CAAC"}

package/dist/migrations/PostgresMigrationAgent.js

@@ -0,0 +1,36 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { migrations } from '@powersync/service-core';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { normalizePostgresStorageConfig } from '../types/types.js';
+import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
+import { PostgresMigrationStore } from './PostgresMigrationStore.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const MIGRATIONS_DIR = path.join(__dirname, 'scripts');
+export class PostgresMigrationAgent extends migrations.AbstractPowerSyncMigrationAgent {
+    store;
+    locks;
+    db;
+    constructor(config) {
+        super();
+        this.db = new lib_postgres.DatabaseClient({
+            config: normalizePostgresStorageConfig(config),
+            schema: STORAGE_SCHEMA_NAME
+        });
+        this.store = new PostgresMigrationStore({
+            db: this.db
+        });
+        this.locks = new lib_postgres.PostgresLockManager({
+            name: 'migrations',
+            db: this.db
+        });
+    }
+    getInternalScriptsDir() {
+        return MIGRATIONS_DIR;
+    }
+    async [Symbol.asyncDispose]() {
+        await this.db[Symbol.asyncDispose]();
+    }
+}
+//# sourceMappingURL=PostgresMigrationAgent.js.map

package/dist/migrations/PostgresMigrationAgent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrationAgent.js","sourceRoot":"","sources":["../../src/migrations/PostgresMigrationAgent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAEpC,OAAO,EAAE,8BAA8B,EAAgC,MAAM,mBAAmB,CAAC;AAEjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;AAE3C,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAEvD,MAAM,OAAO,sBAAuB,SAAQ,UAAU,CAAC,+BAA+B;IACpF,KAAK,CAA2B;IAChC,KAAK,CAAwB;IAEnB,EAAE,CAA8B;IAE1C,YAAY,MAAoC;QAC9C,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,EAAE,GAAG,IAAI,YAAY,CAAC,cAAc,CAAC;YACxC,MAAM,EAAE,8BAA8B,CAAC,MAAM,CAAC;YAC9C,MAAM,EAAE,mBAAmB;SAC5B,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,IAAI,sBAAsB,CAAC;YACtC,EAAE,EAAE,IAAI,CAAC,EAAE;SACZ,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,IAAI,YAAY,CAAC,mBAAmB,CAAC;YAChD,IAAI,EAAE,YAAY;YAClB,EAAE,EAAE,IAAI,CAAC,EAAE;SACZ,CAAC,CAAC;IACL,CAAC;IAED,qBAAqB;QACnB,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;QACzB,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;IACvC,CAAC;CACF"}

package/dist/migrations/PostgresMigrationStore.js

@@ -0,0 +1,60 @@
+import { models } from '../types/types.js';
+import { sql } from '../utils/db.js';
+export class PostgresMigrationStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get db() {
+        return this.options.db;
+    }
+    async init() {
+        await this.db.query(sql `
+      CREATE TABLE IF NOT EXISTS migrations (
+        id SERIAL PRIMARY KEY,
+        last_run TEXT,
+        LOG JSONB NOT NULL
+      );
+    `);
+    }
+    async clear() {
+        await this.db.query(sql `DELETE FROM migrations;`);
+    }
+    async load() {
+        const res = await this.db.sql `
+      SELECT
+        last_run,
+        LOG
+      FROM
+        migrations
+      LIMIT
+        1
+    `
+            .decoded(models.Migration)
+            .first();
+        if (!res) {
+            return;
+        }
+        return {
+            last_run: res.last_run,
+            log: res.log
+        };
+    }
+    async save(state) {
+        await this.db.query(sql `
+      INSERT INTO
+        migrations (id, last_run, LOG)
+      VALUES
+        (
+          1,
+          ${{ type: 'varchar', value: state.last_run }},
+          ${{ type: 'jsonb', value: state.log }}
+        )
+      ON CONFLICT (id) DO UPDATE
+      SET
+        last_run = EXCLUDED.last_run,
+        LOG = EXCLUDED.log;
+    `);
+    }
+}
+//# sourceMappingURL=PostgresMigrationStore.js.map

package/dist/migrations/PostgresMigrationStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrationStore.js","sourceRoot":"","sources":["../../src/migrations/PostgresMigrationStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAMrC,MAAM,OAAO,sBAAsB;IACX;IAAtB,YAAsB,OAAsC;QAAtC,YAAO,GAAP,OAAO,CAA+B;IAAG,CAAC;IAEhE,IAAc,EAAE;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAA;;;;;;KAMtB,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAA,yBAAyB,CAAC,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,GAAG,CAAA;;;;;;;;KAQ5B;aACE,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC;aACzB,KAAK,EAAE,CAAC;QAEX,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO;QACT,CAAC;QAED,OAAO;YACL,QAAQ,EAAE,GAAG,CAAC,QAAQ;YACtB,GAAG,EAAE,GAAG,CAAC,GAAG;SACb,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,KAAgC;QACzC,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAA;;;;;;YAMf,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;YAC1C,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE;;;;;;KAM1C,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/migrations/migration-utils.js

@@ -0,0 +1,13 @@
+import * as lib_postgres from '@powersync/lib-service-postgres';
+import { isPostgresStorageConfig, normalizePostgresStorageConfig, PostgresStorageConfig } from '../types/types.js';
+import { STORAGE_SCHEMA_NAME } from '../utils/db.js';
+export const openMigrationDB = (config) => {
+    if (!isPostgresStorageConfig(config)) {
+        throw new Error(`Input storage configuration is not for Postgres`);
+    }
+    return new lib_postgres.DatabaseClient({
+        config: normalizePostgresStorageConfig(PostgresStorageConfig.decode(config)),
+        schema: STORAGE_SCHEMA_NAME
+    });
+};
+//# sourceMappingURL=migration-utils.js.map

package/dist/migrations/migration-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-utils.js","sourceRoot":"","sources":["../../src/migrations/migration-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,uBAAuB,EAAE,8BAA8B,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACnH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAoC,EAAE,EAAE;IACtE,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,IAAI,YAAY,CAAC,cAAc,CAAC;QACrC,MAAM,EAAE,8BAA8B,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5E,MAAM,EAAE,mBAAmB;KAC5B,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/migrations/scripts/1684951997326-init.js

@@ -0,0 +1,196 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { dropTables } from '../../utils/db.js';
+import { openMigrationDB } from '../migration-utils.js';
+export const up = async (context) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { service_context: { configuration } } = context;
+        const client = __addDisposableResource(env_1, openMigrationDB(configuration.storage), true);
+        /**
+         * Request an explicit connection which will automatically set the search
+         * path to the powersync schema
+         */
+        await client.transaction(async (db) => {
+            await db.sql `
+      CREATE SEQUENCE op_id_sequence AS int8 START
+      WITH
+        1
+    `.execute();
+            await db.sql `
+      CREATE SEQUENCE sync_rules_id_sequence AS int START
+      WITH
+        1
+    `.execute();
+            await db.sql `
+      CREATE TABLE bucket_data (
+        group_id integer NOT NULL,
+        bucket_name TEXT NOT NULL,
+        op_id bigint NOT NULL,
+        CONSTRAINT unique_id PRIMARY KEY (group_id, bucket_name, op_id),
+        op text NOT NULL,
+        source_table TEXT,
+        source_key bytea,
+        table_name TEXT,
+        row_id TEXT,
+        checksum bigint NOT NULL,
+        data TEXT,
+        target_op bigint
+      )
+    `.execute();
+            await db.sql `CREATE TABLE instance (id TEXT PRIMARY KEY) `.execute();
+            await db.sql `
+      CREATE TABLE sync_rules (
+        id INTEGER PRIMARY KEY,
+        state TEXT NOT NULL,
+        snapshot_done BOOLEAN NOT NULL DEFAULT FALSE,
+        last_checkpoint BIGINT,
+        last_checkpoint_lsn TEXT,
+        no_checkpoint_before TEXT,
+        slot_name TEXT,
+        last_checkpoint_ts TIMESTAMP WITH TIME ZONE,
+        last_keepalive_ts TIMESTAMP WITH TIME ZONE,
+        keepalive_op BIGINT,
+        last_fatal_error TEXT,
+        content TEXT NOT NULL
+      );
+    `.execute();
+            await db.sql `
+      CREATE TABLE bucket_parameters (
+        id BIGINT DEFAULT nextval('op_id_sequence') PRIMARY KEY,
+        group_id integer NOT NULL,
+        source_table TEXT NOT NULL,
+        source_key bytea NOT NULL,
+        lookup bytea NOT NULL,
+        --- Stored as text which is stringified with JSONBig
+        --- BigInts are not standard JSON, storing as JSONB seems risky
+        bucket_parameters text NOT NULL
+      );
+    `.execute();
+            await db.sql `
+      CREATE INDEX bucket_parameters_lookup_index ON bucket_parameters (group_id ASC, lookup ASC, id DESC)
+    `.execute();
+            await db.sql `
+      CREATE INDEX bucket_parameters_source_index ON bucket_parameters (group_id, source_table, source_key)
+    `.execute();
+            await db.sql `
+      CREATE TABLE current_data (
+        group_id integer NOT NULL,
+        source_table TEXT NOT NULL,
+        source_key bytea NOT NULL,
+        CONSTRAINT unique_current_data_id PRIMARY KEY (group_id, source_table, source_key),
+        buckets jsonb NOT NULL,
+        data bytea NOT NULL,
+        lookups bytea[] NOT NULL
+      );
+    `.execute();
+            await db.sql `
+      CREATE TABLE source_tables (
+        --- This is currently a TEXT column to make the (shared) tests easier to integrate
+        --- we could improve this if necessary
+        id TEXT PRIMARY KEY,
+        group_id integer NOT NULL,
+        connection_id integer NOT NULL,
+        relation_id jsonb,
+        schema_name text NOT NULL,
+        table_name text NOT NULL,
+        replica_id_columns jsonb,
+        snapshot_done BOOLEAN NOT NULL DEFAULT FALSE
+      )
+    `.execute();
+            await db.sql `CREATE INDEX source_table_lookup ON source_tables (group_id, table_name)`.execute();
+            await db.sql `
+      CREATE TABLE write_checkpoints (
+        user_id text PRIMARY KEY,
+        lsns jsonb NOT NULL,
+        write_checkpoint BIGINT NOT NULL
+      )
+    `.execute();
+            await db.sql `
+      CREATE TABLE custom_write_checkpoints (
+        user_id text NOT NULL,
+        write_checkpoint BIGINT NOT NULL,
+        sync_rules_id integer NOT NULL,
+        CONSTRAINT unique_user_sync PRIMARY KEY (user_id, sync_rules_id)
+      );
+    `.execute();
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+};
+export const down = async (context) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { service_context: { configuration } } = context;
+        const client = __addDisposableResource(env_2, openMigrationDB(configuration.storage), true);
+        await dropTables(client);
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
+};
+//# sourceMappingURL=1684951997326-init.js.map

package/dist/migrations/scripts/1684951997326-init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1684951997326-init.js","sourceRoot":"","sources":["../../../src/migrations/scripts/1684951997326-init.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,MAAM,CAAC,MAAM,EAAE,GAA0C,KAAK,EAAE,OAAO,EAAE,EAAE;;;QACzE,MAAM,EACJ,eAAe,EAAE,EAAE,aAAa,EAAE,EACnC,GAAG,OAAO,CAAC;QACZ,MAAY,MAAM,kCAAG,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,OAAA,CAAC;QAE5D;;;WAGG;QACH,MAAM,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;YACpC,MAAM,EAAE,CAAC,GAAG,CAAA;;;;KAIX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;;;KAIX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;KAeX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA,8CAA8C,CAAC,OAAO,EAAE,CAAC;YAErE,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;KAeX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;;;;;KAWX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;KAEX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;KAEX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;;;;KAUX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;;;;;;;KAaX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA,0EAA0E,CAAC,OAAO,EAAE,CAAC;YAEjG,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;KAMX,CAAC,OAAO,EAAE,CAAC;YAEZ,MAAM,EAAE,CAAC,GAAG,CAAA;;;;;;;KAOX,CAAC,OAAO,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;;;;;;;;;;;CACJ,CAAC;AAEF,MAAM,CAAC,MAAM,IAAI,GAA0C,KAAK,EAAE,OAAO,EAAE,EAAE;;;QAC3E,MAAM,EACJ,eAAe,EAAE,EAAE,aAAa,EAAE,EACnC,GAAG,OAAO,CAAC;QACZ,MAAY,MAAM,kCAAG,eAAe,CAAC,aAAa,CAAC,OAAO,CAAC,OAAA,CAAC;QAE5D,MAAM,UAAU,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;CAC1B,CAAC"}

package/dist/module/PostgresStorageModule.js

@@ -0,0 +1,23 @@
+import { modules } from '@powersync/service-core';
+import { PostgresMigrationAgent } from '../migrations/PostgresMigrationAgent.js';
+import { PostgresStorageProvider } from '../storage/PostgresStorageProvider.js';
+import { isPostgresStorageConfig, PostgresStorageConfig } from '../types/types.js';
+export class PostgresStorageModule extends modules.AbstractModule {
+    constructor() {
+        super({
+            name: 'Postgres Bucket Storage'
+        });
+    }
+    async initialize(context) {
+        const { storageEngine } = context;
+        // Register the ability to use Postgres as a BucketStorage
+        storageEngine.registerProvider(new PostgresStorageProvider());
+        if (isPostgresStorageConfig(context.configuration.storage)) {
+            context.migrations.registerMigrationAgent(new PostgresMigrationAgent(PostgresStorageConfig.decode(context.configuration.storage)));
+        }
+    }
+    async teardown() {
+        // Teardown for this module is implemented in the storage engine
+    }
+}
+//# sourceMappingURL=PostgresStorageModule.js.map

package/dist/module/PostgresStorageModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresStorageModule.js","sourceRoot":"","sources":["../../src/module/PostgresStorageModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,yBAAyB,CAAC;AAE1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAEnF,MAAM,OAAO,qBAAsB,SAAQ,OAAO,CAAC,cAAc;IAC/D;QACE,KAAK,CAAC;YACJ,IAAI,EAAE,yBAAyB;SAChC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,OAAuC;QACtD,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC;QAElC,0DAA0D;QAC1D,aAAa,CAAC,gBAAgB,CAAC,IAAI,uBAAuB,EAAE,CAAC,CAAC;QAE9D,IAAI,uBAAuB,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3D,OAAO,CAAC,UAAU,CAAC,sBAAsB,CACvC,IAAI,sBAAsB,CAAC,qBAAqB,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CACxF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,gEAAgE;IAClE,CAAC;CACF"}