@syncular/typegen 0.15.32 → 0.15.34

package/README.md

@@ -278,6 +278,14 @@ is bare column names: **ASC/DESC**, **expression** columns (`lower(a)`), and
 **partial** (`WHERE …`) indexes are hard errors (the IR models column names
 only, so accepting a direction/expression would silently drop it).
 
+Synced table, column, and secondary-index identifiers are checked against the
+same portable relational rules used by server schema compilation. Names use a
+maximum of **63 UTF-8 bytes** (not JavaScript characters), and `sync_`/`_sync`
+remain reserved for Syncular storage. Generation names the migration, object,
+actual byte count, and portable limit before writing the migration lock or any
+generated artifact. Exactly 63 bytes is accepted. Bare Unicode identifiers are
+supported; quoted identifiers remain outside the migration subset.
+
 **Index replacement** (`DROP INDEX`). A previously declared secondary index
 may be removed with `DROP INDEX name` or conditionally with `IF EXISTS`.
 Generation removes it from the head IR; a later `CREATE INDEX` may reuse the
@@ -285,7 +293,10 @@ name with a different uniqueness or column definition. On a server schema
 bump, Syncular rebuilds the declared secondary indexes for its owned
 relational projection tables before advancing the version marker. Client
 mirrors already wipe and re-bootstrap application tables on every schema
-version change.
+version change. Portability validation applies to the final head schema: an
+already-locked historical index with a non-portable name may therefore be
+dropped and replaced in a forward migration, while a non-portable name that
+remains in the head still fails generation.
 
 **Table retirement** (`DROP TABLE`). A table created earlier in migration
 history and dropped before the head version is absent from the IR and must be

package/dist/generate.js

@@ -21,7 +21,7 @@ import { buildMigrationLock, LEGACY_MIGRATION_LOCK_FORMAT_VERSION, MIGRATION_LOC
 import { buildNamingMap } from './naming.js';
 import { analyzeQueryFile, synthesizeDdl, } from './query.js';
 import { serializeQueryIr } from './query-ir.js';
-import { applyMigrationSql } from './sql.js';
+import { applyMigrationSql, validateFinalSchemaIdentifiers, } from './sql.js';
 import { lowerSyqlQuery } from './syql-lowering.js';
 import { buildSyqlModuleGraph } from './syql-modules.js';
 import { analyzeSyqlSemantics } from './syql-semantics.js';
@@ -159,6 +159,7 @@ export function buildIr(manifest, migrations) {
     for (const migration of migrations) {
         applyMigrationSql(parsedTables, migration.sql, `${migration.name}/up.sql`, droppedTables);
     }
+    validateFinalSchemaIdentifiers(parsedTables);
     const schemaVersions = buildSchemaVersions(manifest, migrations);
     const tables = manifest.tables.map((manifestTable) => {
         const parsed = parsedTables.get(manifestTable.name);

package/dist/sql.d.ts

@@ -8,6 +8,13 @@ export interface ParsedTable {
     /** Client-local contentful FTS5 projections. */
     readonly ftsIndexes: IrFtsIndex[];
 }
+/**
+ * Validate the accumulated head schema after every migration has been
+ * applied. This deliberately permits a locked historical migration to create
+ * an invalid identifier when a later forward migration drops it; only final
+ * generated objects must be portable.
+ */
+export declare function validateFinalSchemaIdentifiers(tables: ReadonlyMap<string, ParsedTable>): void;
 /**
  * Apply one migration file's SQL to the accumulated table map. Columns
  * accumulate in declaration order — the §2.4 row-codec positional order.

package/dist/sql.js

@@ -21,6 +21,7 @@
  * primary keys, ASC/DESC or expression index columns, partial (`WHERE`)
  * indexes — is a hard error naming the unsupported construct.
  */
+import { validatePortableRelationalIdentifier } from '@syncular/core';
 import { TypegenError } from './errors.js';
 /** SQL type keyword → the §2.4 column types. Case-insensitive. */
 const TYPE_MAP = {
@@ -50,9 +51,38 @@ const TYPE_MAP = {
 };
 /** Default `crdtType` for a bare `CRDT` keyword (§5.10.1). */
 const DEFAULT_CRDT_TYPE = 'yjs-doc';
-const WORD_START = /[A-Za-z_]/;
-const WORD_PART = /[A-Za-z0-9_]/;
+const WORD_START = /[\p{L}_]/u;
+const WORD_PART = /[\p{L}\p{M}\p{N}_]/u;
 const DIGIT = /[0-9]/;
+const tableIdentifierSources = new WeakMap();
+const columnIdentifierSources = new WeakMap();
+const indexIdentifierSources = new WeakMap();
+function validateIdentifier(source, kind, identifier) {
+    try {
+        validatePortableRelationalIdentifier(kind, identifier);
+    }
+    catch (error) {
+        throw new TypegenError(source, error instanceof Error ? error.message : 'invalid relational identifier');
+    }
+}
+/**
+ * Validate the accumulated head schema after every migration has been
+ * applied. This deliberately permits a locked historical migration to create
+ * an invalid identifier when a later forward migration drops it; only final
+ * generated objects must be portable.
+ */
+export function validateFinalSchemaIdentifiers(tables) {
+    for (const table of tables.values()) {
+        const tableSource = tableIdentifierSources.get(table) ?? 'migrations';
+        validateIdentifier(tableSource, 'table', table.name);
+        for (const column of table.columns) {
+            validateIdentifier(columnIdentifierSources.get(column) ?? tableSource, `table ${table.name}: column`, column.name);
+        }
+        for (const index of table.indexes) {
+            validateIdentifier(indexIdentifierSources.get(index) ?? tableSource, `table ${table.name}: index`, index.name);
+        }
+    }
+}
 function tokenizeStatements(sql, source) {
     const statements = [];
     let current = [];
@@ -262,11 +292,11 @@ function parseCreate(cursor, tables, droppedTables, source) {
     }
     if (cursor.eatWord('UNIQUE')) {
         cursor.expectWord('INDEX', 'after CREATE UNIQUE');
-        parseCreateIndex(cursor, tables, true);
+        parseCreateIndex(cursor, tables, true, source);
         return;
     }
     if (cursor.eatWord('INDEX')) {
-        parseCreateIndex(cursor, tables, false);
+        parseCreateIndex(cursor, tables, false, source);
         return;
     }
     const token = cursor.peek();
@@ -451,13 +481,18 @@ function parseCreateTable(cursor, tables, droppedTables, source) {
         throw new TypegenError(source, `table ${name}: primary key ${JSON.stringify(primaryKey)} is not a column`);
     }
     const finalColumns = columns.map((c) => c.name === primaryKey ? { ...c, nullable: false } : c);
-    tables.set(name, {
+    const table = {
         name,
         primaryKey,
         columns: finalColumns,
         indexes: [],
         ftsIndexes: [],
-    });
+    };
+    tables.set(name, table);
+    tableIdentifierSources.set(table, source);
+    for (const column of finalColumns) {
+        columnIdentifierSources.set(column, source);
+    }
 }
 /**
  * `CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table (col [, col…])`.
@@ -467,7 +502,7 @@ function parseCreateTable(cursor, tables, droppedTables, source) {
  * (partial index) clause are hard errors naming the construct. Index names
  * are unique per accumulated schema.
  */
-function parseCreateIndex(cursor, tables, unique) {
+function parseCreateIndex(cursor, tables, unique, source) {
     // `INDEX` already matched by the dispatcher.
     if (cursor.eatWord('IF')) {
         cursor.expectWord('NOT', 'after IF');
@@ -527,9 +562,11 @@ function parseCreateIndex(cursor, tables, unique) {
         }
         cursor.fail(`index ${name}: unsupported trailing SQL ${JSON.stringify(trailing.text)}`);
     }
-    table.indexes.push({ name, columns, unique });
+    const index = { name, columns, unique };
+    table.indexes.push(index);
+    indexIdentifierSources.set(index, source);
 }
-function parseAlterTable(cursor, tables) {
+function parseAlterTable(cursor, tables, source) {
     cursor.expectWord('TABLE', 'after ALTER');
     const name = cursor.identifier('a table name');
     const table = tables.get(name);
@@ -550,6 +587,7 @@ function parseAlterTable(cursor, tables) {
         cursor.fail(`ALTER TABLE ${name}: duplicate column ${JSON.stringify(def.column.name)}`);
     }
     table.columns.push(def.column);
+    columnIdentifierSources.set(def.column, source);
 }
 /** `DROP TABLE [IF EXISTS] name`; table-name reuse remains unsupported. */
 function parseDropTable(cursor, tables, droppedTables) {
@@ -613,7 +651,7 @@ export function applyMigrationSql(tables, sql, source, droppedTables = new Set()
             parseCreate(cursor, tables, droppedTables, source);
         }
         else if (word === 'ALTER') {
-            parseAlterTable(cursor, tables);
+            parseAlterTable(cursor, tables, source);
         }
         else if (word === 'DROP') {
             parseDrop(cursor, tables, droppedTables);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.15.32",
+  "version": "0.15.34",
   "description": "Syncular schema-to-TypeScript type generator and the `syncular` CLI",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -55,8 +55,10 @@
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts"
   ],
+  "dependencies": {
+    "@syncular/core": "0.15.34"
+  },
   "devDependencies": {
-    "@syncular/core": "0.15.32",
-    "@syncular/server": "0.15.32"
+    "@syncular/server": "0.15.34"
   }
 }

package/src/generate.ts

@@ -58,7 +58,11 @@ import {
   synthesizeDdl,
 } from './query';
 import { serializeQueryIr } from './query-ir';
-import { applyMigrationSql, type ParsedTable } from './sql';
+import {
+  applyMigrationSql,
+  type ParsedTable,
+  validateFinalSchemaIdentifiers,
+} from './sql';
 import { lowerSyqlQuery } from './syql-lowering';
 import { buildSyqlModuleGraph } from './syql-modules';
 import { analyzeSyqlSemantics } from './syql-semantics';
@@ -282,6 +286,7 @@ export function buildIr(
       droppedTables,
     );
   }
+  validateFinalSchemaIdentifiers(parsedTables);
   const schemaVersions = buildSchemaVersions(manifest, migrations);
   const tables = manifest.tables.map((manifestTable) => {
     const parsed = parsedTables.get(manifestTable.name);

package/src/sql.ts

@@ -21,6 +21,7 @@
  * primary keys, ASC/DESC or expression index columns, partial (`WHERE`)
  * indexes — is a hard error naming the unsupported construct.
  */
+import { validatePortableRelationalIdentifier } from '@syncular/core';
 import { TypegenError } from './errors';
 import type { IrColumn, IrColumnType, IrFtsIndex, IrIndex } from './ir';
 
@@ -69,10 +70,58 @@ interface Token {
   readonly text: string;
 }
 
-const WORD_START = /[A-Za-z_]/;
-const WORD_PART = /[A-Za-z0-9_]/;
+const WORD_START = /[\p{L}_]/u;
+const WORD_PART = /[\p{L}\p{M}\p{N}_]/u;
 const DIGIT = /[0-9]/;
 
+const tableIdentifierSources = new WeakMap<ParsedTable, string>();
+const columnIdentifierSources = new WeakMap<IrColumn, string>();
+const indexIdentifierSources = new WeakMap<IrIndex, string>();
+
+function validateIdentifier(
+  source: string,
+  kind: string,
+  identifier: string,
+): void {
+  try {
+    validatePortableRelationalIdentifier(kind, identifier);
+  } catch (error) {
+    throw new TypegenError(
+      source,
+      error instanceof Error ? error.message : 'invalid relational identifier',
+    );
+  }
+}
+
+/**
+ * Validate the accumulated head schema after every migration has been
+ * applied. This deliberately permits a locked historical migration to create
+ * an invalid identifier when a later forward migration drops it; only final
+ * generated objects must be portable.
+ */
+export function validateFinalSchemaIdentifiers(
+  tables: ReadonlyMap<string, ParsedTable>,
+): void {
+  for (const table of tables.values()) {
+    const tableSource = tableIdentifierSources.get(table) ?? 'migrations';
+    validateIdentifier(tableSource, 'table', table.name);
+    for (const column of table.columns) {
+      validateIdentifier(
+        columnIdentifierSources.get(column) ?? tableSource,
+        `table ${table.name}: column`,
+        column.name,
+      );
+    }
+    for (const index of table.indexes) {
+      validateIdentifier(
+        indexIdentifierSources.get(index) ?? tableSource,
+        `table ${table.name}: index`,
+        index.name,
+      );
+    }
+  }
+}
+
 function tokenizeStatements(sql: string, source: string): Token[][] {
   const statements: Token[][] = [];
   let current: Token[] = [];
@@ -310,11 +359,11 @@ function parseCreate(
   }
   if (cursor.eatWord('UNIQUE')) {
     cursor.expectWord('INDEX', 'after CREATE UNIQUE');
-    parseCreateIndex(cursor, tables, true);
+    parseCreateIndex(cursor, tables, true, source);
     return;
   }
   if (cursor.eatWord('INDEX')) {
-    parseCreateIndex(cursor, tables, false);
+    parseCreateIndex(cursor, tables, false, source);
     return;
   }
   const token = cursor.peek();
@@ -549,13 +598,18 @@ function parseCreateTable(
   const finalColumns = columns.map((c) =>
     c.name === primaryKey ? { ...c, nullable: false } : c,
   );
-  tables.set(name, {
+  const table: ParsedTable = {
     name,
     primaryKey,
     columns: finalColumns,
     indexes: [],
     ftsIndexes: [],
-  });
+  };
+  tables.set(name, table);
+  tableIdentifierSources.set(table, source);
+  for (const column of finalColumns) {
+    columnIdentifierSources.set(column, source);
+  }
 }
 
 /**
@@ -570,6 +624,7 @@ function parseCreateIndex(
   cursor: Cursor,
   tables: Map<string, ParsedTable>,
   unique: boolean,
+  source: string,
 ): void {
   // `INDEX` already matched by the dispatcher.
   if (cursor.eatWord('IF')) {
@@ -646,12 +701,15 @@ function parseCreateIndex(
       `index ${name}: unsupported trailing SQL ${JSON.stringify(trailing.text)}`,
     );
   }
-  table.indexes.push({ name, columns, unique });
+  const index: IrIndex = { name, columns, unique };
+  table.indexes.push(index);
+  indexIdentifierSources.set(index, source);
 }
 
 function parseAlterTable(
   cursor: Cursor,
   tables: Map<string, ParsedTable>,
+  source: string,
 ): void {
   cursor.expectWord('TABLE', 'after ALTER');
   const name = cursor.identifier('a table name');
@@ -679,6 +737,7 @@ function parseAlterTable(
     );
   }
   table.columns.push(def.column);
+  columnIdentifierSources.set(def.column, source);
 }
 
 /** `DROP TABLE [IF EXISTS] name`; table-name reuse remains unsupported. */
@@ -763,7 +822,7 @@ export function applyMigrationSql(
     if (word === 'CREATE') {
       parseCreate(cursor, tables, droppedTables, source);
     } else if (word === 'ALTER') {
-      parseAlterTable(cursor, tables);
+      parseAlterTable(cursor, tables, source);
     } else if (word === 'DROP') {
       parseDrop(cursor, tables, droppedTables);
     } else {