@syncular/server 0.15.11 → 0.15.13

package/dist/d1-storage.js

@@ -309,15 +309,23 @@ export class D1ServerStorage {
             const layouts = parseLayouts(marker?.layouts);
             const retiredTables = retiredTableNames(schema, layouts);
             const existing = new Map();
+            const existingIndexes = new Map();
             for (const table of schema.tables.values()) {
+                const escapedTableName = table.name.replaceAll('"', '""');
                 const { results } = await this.#db
-                    .prepare(`PRAGMA table_info("${table.name.replaceAll('"', '""')}")`)
+                    .prepare(`PRAGMA table_info("${escapedTableName}")`)
                     .all();
                 if (results.length > 0) {
                     existing.set(table.name, new Set(results.map((c) => c.name)));
+                    const indexes = await this.#db
+                        .prepare(`PRAGMA index_list("${escapedTableName}")`)
+                        .all();
+                    existingIndexes.set(table.name, new Set(indexes.results
+                        .filter((index) => index.origin === 'c')
+                        .map((index) => index.name)));
                 }
             }
-            for (const statement of schemaDdl(schema, existing, 'sqlite')) {
+            for (const statement of schemaDdl(schema, existing, 'sqlite', existingIndexes)) {
                 await this.#db.exec(`${statement.replace(/\s+/g, ' ')};`);
             }
             // Migration rewrite: payload re-encode on layout change and/or

package/dist/postgres-storage.js

@@ -449,7 +449,7 @@ export class PostgresServerStorage {
         }
         if (stored === undefined || stored < schema.version) {
             // Introspect existing app tables, apply the migration subset
-            // (CREATE TABLE / ADD COLUMN / CREATE INDEX), then rewrite stored
+            // (CREATE TABLE / ADD COLUMN / rebuild indexes), then rewrite stored
             // rows (payload re-encode for layout changes and/or projection
             // backfill for flipped-on materialization) — all inside one
             // transaction (Postgres DDL is transactional — a failed bump leaves
@@ -460,11 +460,24 @@ export class PostgresServerStorage {
             const retiredTables = retiredTableNames(schema, layouts);
             await this.#exec.transaction(async (client) => {
                 const existing = new Map();
+                const existingIndexes = new Map();
                 for (const table of schema.tables.values()) {
                     const { rows } = await client.query(`SELECT column_name FROM information_schema.columns
              WHERE table_schema = current_schema() AND table_name = $1`, [table.name]);
                     if (rows.length > 0) {
                         existing.set(table.name, new Set(rows.map((r) => r.column_name)));
+                        const indexes = await client.query(`SELECT index_class.relname AS index_name
+                 FROM pg_catalog.pg_class AS table_class
+                 JOIN pg_catalog.pg_namespace AS namespace
+                   ON namespace.oid = table_class.relnamespace
+                 JOIN pg_catalog.pg_index AS index_meta
+                   ON index_meta.indrelid = table_class.oid
+                 JOIN pg_catalog.pg_class AS index_class
+                   ON index_class.oid = index_meta.indexrelid
+                WHERE namespace.nspname = current_schema()
+                  AND table_class.relname = $1
+                  AND NOT index_meta.indisprimary`, [table.name]);
+                        existingIndexes.set(table.name, new Set(indexes.rows.map((index) => index.index_name)));
                     }
                 }
                 for (const tableName of retiredTables) {
@@ -473,7 +486,7 @@ export class PostgresServerStorage {
                     ]);
                     await client.query(dropTableDdl(tableName));
                 }
-                for (const statement of schemaDdl(schema, existing, 'postgres')) {
+                for (const statement of schemaDdl(schema, existing, 'postgres', existingIndexes)) {
                     await client.query(statement);
                 }
                 for (const table of schema.tables.values()) {

package/dist/relational-rows.d.ts

@@ -76,6 +76,8 @@ export declare function addColumnDdl(table: CompiledTable, existingColumns: Read
  * as it is client-side).
  */
 export declare function createIndexDdl(table: CompiledTable): string[];
+/** Idempotent removal of one Syncular-owned relational projection index. */
+export declare function dropIndexDdl(indexName: string): string;
 /**
  * Convert one decoded row value to its SQL bind value.
  * - boolean → 0/1 on sqlite (INTEGER affinity), native on postgres;
@@ -229,9 +231,10 @@ export declare function rewritePlan(table: CompiledTable, oldLayout: readonly St
     backfill: boolean;
 };
 /**
- * Every DDL statement to bring a database from `existingColumnsByTable`
- * (introspected; a missing key = table absent) to `schema`: CREATE TABLE
- * for absent tables, ADD COLUMN for missing columns, CREATE INDEX for the
- * declared user indexes — exactly the migration subset.
+ * Every DDL statement to bring a database from the introspected relational
+ * projections to `schema`: CREATE TABLE for absent tables, ADD COLUMN for
+ * missing columns, and rebuild declared secondary indexes. Rebuilding during
+ * a version bump supports DROP INDEX and same-name index replacement without
+ * requiring historical index definitions in the stored column-layout marker.
  */
-export declare function schemaDdl(schema: CompiledSchema, existingColumnsByTable: ReadonlyMap<string, ReadonlySet<string>>, dialect: RelationalDialect): string[];
+export declare function schemaDdl(schema: CompiledSchema, existingColumnsByTable: ReadonlyMap<string, ReadonlySet<string>>, dialect: RelationalDialect, existingIndexesByTable?: ReadonlyMap<string, ReadonlySet<string>>): string[];

package/dist/relational-rows.js

@@ -162,6 +162,10 @@ export function createIndexDdl(table) {
         return `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdent(index.name)} ON ${quoteIdent(table.name)} (${columns})`;
     });
 }
+/** Idempotent removal of one Syncular-owned relational projection index. */
+export function dropIndexDdl(indexName) {
+    return `DROP INDEX IF EXISTS ${quoteIdent(indexName)}`;
+}
 /**
  * Convert one decoded row value to its SQL bind value.
  * - boolean → 0/1 on sqlite (INTEGER affinity), native on postgres;
@@ -399,7 +403,7 @@ export function dropTableDdl(tableName) {
  */
 export function assertAppendOnlyMigration(tableName, oldLayout, table) {
     if (oldLayout.length > table.columns.length) {
-        throw new Error(`table ${JSON.stringify(tableName)}: the schema removed columns — only CREATE TABLE / ADD COLUMN / CREATE INDEX migrations are supported`);
+        throw new Error(`table ${JSON.stringify(tableName)}: the schema removed columns — only appending nullable columns is supported; indexes may be created, replaced, or dropped independently`);
     }
     for (let i = 0; i < oldLayout.length; i++) {
         const before = oldLayout[i];
@@ -503,12 +507,13 @@ export function rewritePlan(table, oldLayout, physicalColumnsBefore) {
     return { migrate, backfill };
 }
 /**
- * Every DDL statement to bring a database from `existingColumnsByTable`
- * (introspected; a missing key = table absent) to `schema`: CREATE TABLE
- * for absent tables, ADD COLUMN for missing columns, CREATE INDEX for the
- * declared user indexes — exactly the migration subset.
+ * Every DDL statement to bring a database from the introspected relational
+ * projections to `schema`: CREATE TABLE for absent tables, ADD COLUMN for
+ * missing columns, and rebuild declared secondary indexes. Rebuilding during
+ * a version bump supports DROP INDEX and same-name index replacement without
+ * requiring historical index definitions in the stored column-layout marker.
  */
-export function schemaDdl(schema, existingColumnsByTable, dialect) {
+export function schemaDdl(schema, existingColumnsByTable, dialect, existingIndexesByTable = new Map()) {
     const out = [];
     for (const table of schema.tables.values()) {
         const existing = existingColumnsByTable.get(table.name);
@@ -516,6 +521,9 @@ export function schemaDdl(schema, existingColumnsByTable, dialect) {
             out.push(createTableDdl(table, dialect));
         }
         else {
+            for (const indexName of existingIndexesByTable.get(table.name) ?? []) {
+                out.push(dropIndexDdl(indexName));
+            }
             out.push(...addColumnDdl(table, existing, dialect));
         }
         out.push(...createIndexDdl(table));

package/dist/sqlite-storage.js

@@ -138,19 +138,26 @@ export class SqliteServerStorage {
         }
         if (marker === null || marker.schema_version < schema.version) {
             // Introspect existing app tables, then apply the migration subset
-            // (CREATE TABLE / ADD COLUMN / CREATE INDEX) to reach `schema`, then
+            // (CREATE TABLE / ADD COLUMN / rebuild indexes) to reach `schema`, then
             // rewrite stored rows (payload re-encode for layout changes, and/or
             // projection backfill for flipped-on materialization). One
             // transaction: a failed bump leaves no half-state.
             const layouts = parseLayouts(marker?.layouts);
             const retiredTables = retiredTableNames(schema, layouts);
             const existing = new Map();
+            const existingIndexes = new Map();
             for (const table of schema.tables.values()) {
+                const escapedTableName = table.name.replaceAll('"', '""');
                 const columns = this.db
-                    .query(`PRAGMA table_info("${table.name.replaceAll('"', '""')}")`)
+                    .query(`PRAGMA table_info("${escapedTableName}")`)
                     .all();
                 if (columns.length > 0) {
                     existing.set(table.name, new Set(columns.map((c) => c.name)));
+                    const indexes = this.db
+                        .query(`PRAGMA index_list("${escapedTableName}")`)
+                        .all()
+                        .filter((index) => index.origin === 'c');
+                    existingIndexes.set(table.name, new Set(indexes.map((index) => index.name)));
                 }
             }
             this.db.exec('BEGIN IMMEDIATE');
@@ -161,7 +168,7 @@ export class SqliteServerStorage {
                         .run(tableName);
                     this.db.exec(dropTableDdl(tableName));
                 }
-                for (const statement of schemaDdl(schema, existing, 'sqlite')) {
+                for (const statement of schemaDdl(schema, existing, 'sqlite', existingIndexes)) {
                     this.db.exec(statement);
                 }
                 for (const table of schema.tables.values()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.15.11",
+  "version": "0.15.13",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -53,7 +53,7 @@
     "!dist/**/*.test.d.ts"
   ],
   "dependencies": {
-    "@syncular/core": "0.15.11"
+    "@syncular/core": "0.15.13"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"

package/src/d1-storage.ts

@@ -493,15 +493,33 @@ export class D1ServerStorage implements ServerStorage {
       const layouts = parseLayouts(marker?.layouts);
       const retiredTables = retiredTableNames(schema, layouts);
       const existing = new Map<string, ReadonlySet<string>>();
+      const existingIndexes = new Map<string, ReadonlySet<string>>();
       for (const table of schema.tables.values()) {
+        const escapedTableName = table.name.replaceAll('"', '""');
         const { results } = await this.#db
-          .prepare(`PRAGMA table_info("${table.name.replaceAll('"', '""')}")`)
+          .prepare(`PRAGMA table_info("${escapedTableName}")`)
           .all<{ name: string }>();
         if (results.length > 0) {
           existing.set(table.name, new Set(results.map((c) => c.name)));
+          const indexes = await this.#db
+            .prepare(`PRAGMA index_list("${escapedTableName}")`)
+            .all<{ name: string; origin: string }>();
+          existingIndexes.set(
+            table.name,
+            new Set(
+              indexes.results
+                .filter((index) => index.origin === 'c')
+                .map((index) => index.name),
+            ),
+          );
         }
       }
-      for (const statement of schemaDdl(schema, existing, 'sqlite')) {
+      for (const statement of schemaDdl(
+        schema,
+        existing,
+        'sqlite',
+        existingIndexes,
+      )) {
         await this.#db.exec(`${statement.replace(/\s+/g, ' ')};`);
       }
       // Migration rewrite: payload re-encode on layout change and/or

package/src/postgres-storage.ts

@@ -713,7 +713,7 @@ export class PostgresServerStorage implements ServerStorage {
     }
     if (stored === undefined || stored < schema.version) {
       // Introspect existing app tables, apply the migration subset
-      // (CREATE TABLE / ADD COLUMN / CREATE INDEX), then rewrite stored
+      // (CREATE TABLE / ADD COLUMN / rebuild indexes), then rewrite stored
       // rows (payload re-encode for layout changes and/or projection
       // backfill for flipped-on materialization) — all inside one
       // transaction (Postgres DDL is transactional — a failed bump leaves
@@ -726,6 +726,7 @@ export class PostgresServerStorage implements ServerStorage {
       const retiredTables = retiredTableNames(schema, layouts);
       await this.#exec.transaction(async (client) => {
         const existing = new Map<string, ReadonlySet<string>>();
+        const existingIndexes = new Map<string, ReadonlySet<string>>();
         for (const table of schema.tables.values()) {
           const { rows } = await client.query<{ column_name: string }>(
             `SELECT column_name FROM information_schema.columns
@@ -734,6 +735,24 @@ export class PostgresServerStorage implements ServerStorage {
           );
           if (rows.length > 0) {
             existing.set(table.name, new Set(rows.map((r) => r.column_name)));
+            const indexes = await client.query<{ index_name: string }>(
+              `SELECT index_class.relname AS index_name
+                 FROM pg_catalog.pg_class AS table_class
+                 JOIN pg_catalog.pg_namespace AS namespace
+                   ON namespace.oid = table_class.relnamespace
+                 JOIN pg_catalog.pg_index AS index_meta
+                   ON index_meta.indrelid = table_class.oid
+                 JOIN pg_catalog.pg_class AS index_class
+                   ON index_class.oid = index_meta.indexrelid
+                WHERE namespace.nspname = current_schema()
+                  AND table_class.relname = $1
+                  AND NOT index_meta.indisprimary`,
+              [table.name],
+            );
+            existingIndexes.set(
+              table.name,
+              new Set(indexes.rows.map((index) => index.index_name)),
+            );
           }
         }
         for (const tableName of retiredTables) {
@@ -742,7 +761,12 @@ export class PostgresServerStorage implements ServerStorage {
           ]);
           await client.query(dropTableDdl(tableName));
         }
-        for (const statement of schemaDdl(schema, existing, 'postgres')) {
+        for (const statement of schemaDdl(
+          schema,
+          existing,
+          'postgres',
+          existingIndexes,
+        )) {
           await client.query(statement);
         }
         for (const table of schema.tables.values()) {

package/src/relational-rows.ts

@@ -188,6 +188,11 @@ export function createIndexDdl(table: CompiledTable): string[] {
   });
 }
 
+/** Idempotent removal of one Syncular-owned relational projection index. */
+export function dropIndexDdl(indexName: string): string {
+  return `DROP INDEX IF EXISTS ${quoteIdent(indexName)}`;
+}
+
 /**
  * Convert one decoded row value to its SQL bind value.
  * - boolean → 0/1 on sqlite (INTEGER affinity), native on postgres;
@@ -481,7 +486,7 @@ export function assertAppendOnlyMigration(
 ): boolean {
   if (oldLayout.length > table.columns.length) {
     throw new Error(
-      `table ${JSON.stringify(tableName)}: the schema removed columns — only CREATE TABLE / ADD COLUMN / CREATE INDEX migrations are supported`,
+      `table ${JSON.stringify(tableName)}: the schema removed columns — only appending nullable columns is supported; indexes may be created, replaced, or dropped independently`,
     );
   }
   for (let i = 0; i < oldLayout.length; i++) {
@@ -624,15 +629,17 @@ export function rewritePlan(
 }
 
 /**
- * Every DDL statement to bring a database from `existingColumnsByTable`
- * (introspected; a missing key = table absent) to `schema`: CREATE TABLE
- * for absent tables, ADD COLUMN for missing columns, CREATE INDEX for the
- * declared user indexes — exactly the migration subset.
+ * Every DDL statement to bring a database from the introspected relational
+ * projections to `schema`: CREATE TABLE for absent tables, ADD COLUMN for
+ * missing columns, and rebuild declared secondary indexes. Rebuilding during
+ * a version bump supports DROP INDEX and same-name index replacement without
+ * requiring historical index definitions in the stored column-layout marker.
  */
 export function schemaDdl(
   schema: CompiledSchema,
   existingColumnsByTable: ReadonlyMap<string, ReadonlySet<string>>,
   dialect: RelationalDialect,
+  existingIndexesByTable: ReadonlyMap<string, ReadonlySet<string>> = new Map(),
 ): string[] {
   const out: string[] = [];
   for (const table of schema.tables.values()) {
@@ -640,6 +647,9 @@ export function schemaDdl(
     if (existing === undefined) {
       out.push(createTableDdl(table, dialect));
     } else {
+      for (const indexName of existingIndexesByTable.get(table.name) ?? []) {
+        out.push(dropIndexDdl(indexName));
+      }
       out.push(...addColumnDdl(table, existing, dialect));
     }
     out.push(...createIndexDdl(table));

package/src/sqlite-storage.ts

@@ -270,21 +270,33 @@ export class SqliteServerStorage implements ServerStorage {
     }
     if (marker === null || marker.schema_version < schema.version) {
       // Introspect existing app tables, then apply the migration subset
-      // (CREATE TABLE / ADD COLUMN / CREATE INDEX) to reach `schema`, then
+      // (CREATE TABLE / ADD COLUMN / rebuild indexes) to reach `schema`, then
       // rewrite stored rows (payload re-encode for layout changes, and/or
       // projection backfill for flipped-on materialization). One
       // transaction: a failed bump leaves no half-state.
       const layouts = parseLayouts(marker?.layouts);
       const retiredTables = retiredTableNames(schema, layouts);
       const existing = new Map<string, ReadonlySet<string>>();
+      const existingIndexes = new Map<string, ReadonlySet<string>>();
       for (const table of schema.tables.values()) {
+        const escapedTableName = table.name.replaceAll('"', '""');
         const columns = this.db
           .query<{ name: string }, []>(
-            `PRAGMA table_info("${table.name.replaceAll('"', '""')}")`,
+            `PRAGMA table_info("${escapedTableName}")`,
           )
           .all();
         if (columns.length > 0) {
           existing.set(table.name, new Set(columns.map((c) => c.name)));
+          const indexes = this.db
+            .query<{ name: string; origin: string }, []>(
+              `PRAGMA index_list("${escapedTableName}")`,
+            )
+            .all()
+            .filter((index) => index.origin === 'c');
+          existingIndexes.set(
+            table.name,
+            new Set(indexes.map((index) => index.name)),
+          );
         }
       }
       this.db.exec('BEGIN IMMEDIATE');
@@ -295,7 +307,12 @@ export class SqliteServerStorage implements ServerStorage {
             .run(tableName);
           this.db.exec(dropTableDdl(tableName));
         }
-        for (const statement of schemaDdl(schema, existing, 'sqlite')) {
+        for (const statement of schemaDdl(
+          schema,
+          existing,
+          'sqlite',
+          existingIndexes,
+        )) {
           this.db.exec(statement);
         }
         for (const table of schema.tables.values()) {