@powersync/service-module-postgres 0.19.2 → 0.19.4

package/test/src/util.ts

@@ -1,151 +0,0 @@
-import { PostgresRouteAPIAdapter } from '@module/api/PostgresRouteAPIAdapter.js';
-import * as types from '@module/types/types.js';
-import * as lib_postgres from '@powersync/lib-service-postgres';
-import { logger } from '@powersync/lib-services-framework';
-import {
-  BucketStorageFactory,
-  CURRENT_STORAGE_VERSION,
-  InternalOpId,
-  LEGACY_STORAGE_VERSION,
-  SUPPORTED_STORAGE_VERSIONS,
-  TestStorageConfig,
-  TestStorageFactory
-} from '@powersync/service-core';
-import * as pgwire from '@powersync/service-jpgwire';
-import * as mongo_storage from '@powersync/service-module-mongodb-storage';
-import * as postgres_storage from '@powersync/service-module-postgres-storage';
-import { describe, TestOptions } from 'vitest';
-import { env } from './env.js';
-
-export const TEST_URI = env.PG_TEST_URL;
-
-export const INITIALIZED_MONGO_STORAGE_FACTORY = mongo_storage.test_utils.mongoTestStorageFactoryGenerator({
-  url: env.MONGO_TEST_URL,
-  isCI: env.CI
-});
-
-export const INITIALIZED_POSTGRES_STORAGE_FACTORY = postgres_storage.test_utils.postgresTestSetup({
-  url: env.PG_STORAGE_TEST_URL
-});
-
-const TEST_STORAGE_VERSIONS = SUPPORTED_STORAGE_VERSIONS;
-
-export interface StorageVersionTestContext {
-  factory: TestStorageFactory;
-  storageVersion: number;
-}
-
-export function describeWithStorage(
-  options: TestOptions & { storageVersions?: number[] },
-  fn: (context: StorageVersionTestContext) => void
-) {
-  const storageVersions = options.storageVersions ?? TEST_STORAGE_VERSIONS;
-  const describeFactory = (storageName: string, config: TestStorageConfig) => {
-    describe(`${storageName} storage`, options, function () {
-      for (const storageVersion of storageVersions) {
-        describe(`storage v${storageVersion}`, function () {
-          fn({
-            factory: config.factory,
-            storageVersion
-          });
-        });
-      }
-    });
-  };
-
-  if (env.TEST_MONGO_STORAGE) {
-    describeFactory('mongodb', INITIALIZED_MONGO_STORAGE_FACTORY);
-  }
-
-  if (env.TEST_POSTGRES_STORAGE) {
-    describeFactory('postgres', INITIALIZED_POSTGRES_STORAGE_FACTORY);
-  }
-}
-
-export const TEST_CONNECTION_OPTIONS = types.normalizeConnectionConfig({
-  type: 'postgresql',
-  uri: TEST_URI,
-  sslmode: 'disable'
-});
-
-export async function clearTestDb(db: pgwire.PgClient) {
-  await db.query(
-    "select pg_drop_replication_slot(slot_name) from pg_replication_slots where active = false and slot_name like 'test_%'"
-  );
-
-  await db.query(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
-  try {
-    await db.query(`DROP PUBLICATION powersync`);
-  } catch (e) {
-    // Ignore
-  }
-
-  await db.query(`CREATE PUBLICATION powersync FOR ALL TABLES`);
-
-  const tableRows = pgwire.pgwireRows(
-    await db.query(`SELECT table_name FROM information_schema.tables where table_schema = 'public'`)
-  );
-  for (let row of tableRows) {
-    const name = row.table_name;
-    if (name.startsWith('test_')) {
-      await db.query(`DROP TABLE public.${lib_postgres.escapeIdentifier(name)}`);
-    }
-  }
-
-  const domainRows = pgwire.pgwireRows(
-    await db.query(`
-      SELECT typname,typtype
-      FROM pg_type t
-        LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-      WHERE n.nspname = 'public' AND typarray != 0
-    `)
-  );
-  for (let row of domainRows) {
-    if (row.typtype == 'd') {
-      await db.query(`DROP DOMAIN public.${lib_postgres.escapeIdentifier(row.typname)} CASCADE`);
-    } else {
-      await db.query(`DROP TYPE public.${lib_postgres.escapeIdentifier(row.typname)} CASCADE`);
-    }
-  }
-}
-
-export async function connectPgWire(type?: 'replication' | 'standard') {
-  const db = await pgwire.connectPgWire(TEST_CONNECTION_OPTIONS, { type, applicationName: 'powersync-tests' });
-  return db;
-}
-
-export function connectPgPool() {
-  const db = pgwire.connectPgWirePool(TEST_CONNECTION_OPTIONS);
-  return db;
-}
-
-export async function getClientCheckpoint(
-  db: pgwire.PgClient,
-  storageFactory: BucketStorageFactory,
-  options?: { timeout?: number }
-): Promise<InternalOpId> {
-  const start = Date.now();
-
-  const api = new PostgresRouteAPIAdapter(db);
-  const lsn = await api.createReplicationHead(async (lsn) => lsn);
-
-  // This old API needs a persisted checkpoint id.
-  // Since we don't use LSNs anymore, the only way to get that is to wait.
-
-  const timeout = options?.timeout ?? 50_000;
-
-  logger.info(`Waiting for LSN checkpoint: ${lsn}`);
-  while (Date.now() - start < timeout) {
-    const storage = await storageFactory.getActiveStorage();
-    const cp = await storage?.getCheckpoint();
-
-    if (cp?.lsn != null && cp.lsn >= lsn) {
-      logger.info(`Got write checkpoint: ${lsn} : ${cp.checkpoint}`);
-      return cp.checkpoint;
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-
-  throw new Error('Timeout while waiting for checkpoint');
-}

package/test/src/validation.test.ts

@@ -1,63 +0,0 @@
-import { getDebugTablesInfo } from '@module/replication/replication-utils.js';
-import { expect, test } from 'vitest';
-
-import { INITIALIZED_MONGO_STORAGE_FACTORY } from './util.js';
-import { WalStreamTestContext } from './wal_stream_utils.js';
-import { updateSyncRulesFromYaml } from '@powersync/service-core';
-
-test('validate tables', async () => {
-  await using context = await WalStreamTestContext.open(INITIALIZED_MONGO_STORAGE_FACTORY.factory);
-  const { pool } = context;
-
-  await pool.query(`CREATE TABLE test_data(id uuid primary key default uuid_generate_v4(), description text)`);
-
-  const syncRuleContent = `
-bucket_definitions:
-  global:
-    data:
-      - SELECT id, description FROM "test_data"
-      - SELECT * FROM "other"
-      - SELECT * FROM "other%"
-`;
-
-  const syncRules = await context.factory.updateSyncRules(updateSyncRulesFromYaml(syncRuleContent));
-
-  const tablePatterns = syncRules.parsed({ defaultSchema: 'public' }).sync_rules.config.getSourceTables();
-  const tableInfo = await getDebugTablesInfo({
-    db: pool,
-    publicationName: context.publicationName,
-    connectionTag: context.connectionTag,
-    tablePatterns: tablePatterns,
-    syncRules: syncRules.parsed({ defaultSchema: 'public' }).sync_rules.config
-  });
-  expect(tableInfo).toEqual([
-    {
-      schema: 'public',
-      pattern: 'test_data',
-      wildcard: false,
-      table: {
-        schema: 'public',
-        name: 'test_data',
-        replication_id: ['id'],
-        pattern: undefined,
-        data_queries: true,
-        parameter_queries: false,
-        errors: []
-      }
-    },
-    {
-      schema: 'public',
-      pattern: 'other',
-      wildcard: false,
-      table: {
-        schema: 'public',
-        name: 'other',
-        replication_id: [],
-        data_queries: true,
-        parameter_queries: false,
-        errors: [{ level: 'warning', message: 'Table "public"."other" not found.' }]
-      }
-    },
-    { schema: 'public', pattern: 'other%', wildcard: true, tables: [] }
-  ]);
-});