@syncular/typegen 0.11.0 → 0.12.0

package/README.md

@@ -184,6 +184,7 @@ duplicate ordinals are errors). The parser accepts exactly:
 - `CREATE TABLE [IF NOT EXISTS] name ( column-defs…, [PRIMARY KEY (col)] ) [WITHOUT ROWID]`
 - `ALTER TABLE name ADD [COLUMN] column-def`
 - `CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table ( col [, col…] )`
+- `DROP TABLE [IF EXISTS] name`
 - column-def: `name TYPE [PRIMARY KEY] [NOT NULL] [NULL] [DEFAULT literal]`
 - `--` line comments and `/* … */` block comments
 
@@ -206,21 +207,27 @@ inline or table-level.
 secondary indexes on an already-created table: `CREATE INDEX name ON table
 (col)`, a compound `… (a, b)` (order preserved), the `UNIQUE` variant, and
 `IF NOT EXISTS`. Each index becomes an `Ir​Table.indexes` entry
-(`{ name, columns, unique }`, declaration order) and is materialized as a real
-SQLite index by the **clients** (the TS web-client mirror + the Rust core's
-base/visible table pair) and by typegen's own named-query type-check DB. Index
-columns must exist on the table; index names must be unique across the schema;
-a column must not repeat within one index. **Indexes are client-side only**:
-the server stores rows in a generic `sync_rows` table with an opaque payload
-(no per-user-table SQL columns exist server-side), so a user-column index has
-nothing to attach to there — the scope inverted-index already covers server
-reads. The column list 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).
+(`{ name, columns, unique }`, declaration order) and is materialized by the
+clients (the TS web-client mirror + the Rust core's base/visible table pair),
+typegen's named-query type-check DB, and the server's relational app-table
+projection. Index columns must exist on the table; index names must be unique
+across the schema; a column must not repeat within one index. The column list
+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).
+
+**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
+omitted from the manifest's `tables` list. `IF EXISTS` is supported. Reusing a
+dropped table name is rejected: the head-only IR cannot distinguish a new
+table from an incompatible in-place rewrite on an upgrading server. On a
+schema-version bump, clients wipe and re-bootstrap their synced tables; the
+reference relational server drops the retired current-row table and its live
+scope index. Append-only commit history follows the configured retention
+policy—`DROP TABLE` is schema retirement, not a compliance erasure API.
 
 **Hard errors** (each names the construct and source file): any other
-statement (`CREATE TRIGGER/VIEW`, `DROP`, DML, `ALTER … RENAME`, …); unknown
+statement (`CREATE TRIGGER/VIEW`, `DROP INDEX`, DML, `ALTER … RENAME`, …); unknown
 or parameterized types (`VARCHAR(36)`); quoted identifiers
 (`"t"`, `` `t` ``, `[t]`); table constraints (`FOREIGN KEY`, `UNIQUE`,
 `CHECK`, `CONSTRAINT`); column constraints beyond the list above

package/dist/generate.js

@@ -152,8 +152,9 @@ export function buildIr(manifest, migrations) {
         throw new TypegenError(MANIFEST_FILENAME, 'no migrations found');
     }
     const parsedTables = new Map();
+    const droppedTables = new Set();
     for (const migration of migrations) {
-        applyMigrationSql(parsedTables, migration.sql, `${migration.name}/up.sql`);
+        applyMigrationSql(parsedTables, migration.sql, `${migration.name}/up.sql`, droppedTables);
     }
     const schemaVersions = buildSchemaVersions(manifest, migrations);
     const tables = manifest.tables.map((manifestTable) => {

package/dist/sql.d.ts

@@ -10,4 +10,4 @@ export interface ParsedTable {
  * Apply one migration file's SQL to the accumulated table map. Columns
  * accumulate in declaration order — the §2.4 row-codec positional order.
  */
-export declare function applyMigrationSql(tables: Map<string, ParsedTable>, sql: string, source: string): void;
+export declare function applyMigrationSql(tables: Map<string, ParsedTable>, sql: string, source: string, droppedTables?: Set<string>): void;

package/dist/sql.js

@@ -7,6 +7,7 @@
  *   [WITHOUT ROWID]`
  * - `ALTER TABLE name ADD [COLUMN] coldef`
  * - `CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table (col [, col…])`
+ * - `DROP TABLE [IF EXISTS] name`
  * - column defs: `name TYPE [PRIMARY KEY] [NOT NULL] [NULL]
  *   [DEFAULT literal]`
  * - `--` and C-style comments
@@ -246,9 +247,9 @@ function parseColumnDef(cursor, allowPrimaryKey) {
  * Dispatch a `CREATE …` statement: `CREATE TABLE`, `CREATE INDEX`, or
  * `CREATE UNIQUE INDEX`. Anything else is a hard error naming the construct.
  */
-function parseCreate(cursor, tables, source) {
+function parseCreate(cursor, tables, droppedTables, source) {
     if (cursor.eatWord('TABLE')) {
-        parseCreateTable(cursor, tables, source);
+        parseCreateTable(cursor, tables, droppedTables, source);
         return;
     }
     if (cursor.eatWord('UNIQUE')) {
@@ -263,12 +264,15 @@ function parseCreate(cursor, tables, source) {
     const token = cursor.peek();
     cursor.fail(`unsupported CREATE statement (only CREATE TABLE and CREATE [UNIQUE] INDEX), found ${JSON.stringify(token?.text ?? '')}`);
 }
-function parseCreateTable(cursor, tables, source) {
+function parseCreateTable(cursor, tables, droppedTables, source) {
     if (cursor.eatWord('IF')) {
         cursor.expectWord('NOT', 'after IF');
         cursor.expectWord('EXISTS', 'after IF NOT');
     }
     const name = cursor.identifier('a table name');
+    if (droppedTables.has(name)) {
+        cursor.fail(`table ${name} cannot be re-created after DROP TABLE — table-name reuse is unsupported`);
+    }
     if (tables.has(name)) {
         cursor.fail(`table ${name} is created twice`);
     }
@@ -418,23 +422,44 @@ function parseAlterTable(cursor, tables) {
     }
     table.columns.push(def.column);
 }
+/** `DROP TABLE [IF EXISTS] name`; table-name reuse remains unsupported. */
+function parseDropTable(cursor, tables, droppedTables) {
+    cursor.expectWord('TABLE', 'after DROP');
+    let ifExists = false;
+    if (cursor.eatWord('IF')) {
+        cursor.expectWord('EXISTS', 'after IF');
+        ifExists = true;
+    }
+    const name = cursor.identifier('a table name');
+    cursor.expectEnd();
+    if (!tables.has(name)) {
+        if (ifExists)
+            return;
+        cursor.fail(`DROP TABLE ${name}: table does not exist at this point`);
+    }
+    tables.delete(name);
+    droppedTables.add(name);
+}
 /**
  * Apply one migration file's SQL to the accumulated table map. Columns
  * accumulate in declaration order — the §2.4 row-codec positional order.
  */
-export function applyMigrationSql(tables, sql, source) {
+export function applyMigrationSql(tables, sql, source, droppedTables = new Set()) {
     for (const tokens of tokenizeStatements(sql, source)) {
         const cursor = new Cursor(tokens, source);
         const head = cursor.next();
         const word = head.kind === 'word' ? head.text.toUpperCase() : '';
         if (word === 'CREATE') {
-            parseCreate(cursor, tables, source);
+            parseCreate(cursor, tables, droppedTables, source);
         }
         else if (word === 'ALTER') {
             parseAlterTable(cursor, tables);
         }
+        else if (word === 'DROP') {
+            parseDropTable(cursor, tables, droppedTables);
+        }
         else {
-            throw new TypegenError(source, `unsupported SQL statement starting with ${JSON.stringify(head.text)} (only CREATE TABLE, CREATE [UNIQUE] INDEX, and ALTER TABLE … ADD COLUMN)`);
+            throw new TypegenError(source, `unsupported SQL statement starting with ${JSON.stringify(head.text)} (only CREATE TABLE, CREATE [UNIQUE] INDEX, ALTER TABLE … ADD COLUMN, and DROP TABLE)`);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Syncular schema-to-TypeScript type generator and the `syncular` CLI",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -48,7 +48,7 @@
     "!dist/**/*.test.d.ts"
   ],
   "devDependencies": {
-    "@syncular/core": "0.11.0",
-    "@syncular/server": "0.11.0"
+    "@syncular/core": "0.12.0",
+    "@syncular/server": "0.12.0"
   }
 }

package/src/generate.ts

@@ -263,8 +263,14 @@ export function buildIr(
     throw new TypegenError(MANIFEST_FILENAME, 'no migrations found');
   }
   const parsedTables = new Map<string, ParsedTable>();
+  const droppedTables = new Set<string>();
   for (const migration of migrations) {
-    applyMigrationSql(parsedTables, migration.sql, `${migration.name}/up.sql`);
+    applyMigrationSql(
+      parsedTables,
+      migration.sql,
+      `${migration.name}/up.sql`,
+      droppedTables,
+    );
   }
   const schemaVersions = buildSchemaVersions(manifest, migrations);
   const tables = manifest.tables.map((manifestTable) => {

package/src/sql.ts

@@ -7,6 +7,7 @@
  *   [WITHOUT ROWID]`
  * - `ALTER TABLE name ADD [COLUMN] coldef`
  * - `CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table (col [, col…])`
+ * - `DROP TABLE [IF EXISTS] name`
  * - column defs: `name TYPE [PRIMARY KEY] [NOT NULL] [NULL]
  *   [DEFAULT literal]`
  * - `--` and C-style comments
@@ -290,10 +291,11 @@ function parseColumnDef(cursor: Cursor, allowPrimaryKey: boolean): ColumnDef {
 function parseCreate(
   cursor: Cursor,
   tables: Map<string, ParsedTable>,
+  droppedTables: ReadonlySet<string>,
   source: string,
 ): void {
   if (cursor.eatWord('TABLE')) {
-    parseCreateTable(cursor, tables, source);
+    parseCreateTable(cursor, tables, droppedTables, source);
     return;
   }
   if (cursor.eatWord('UNIQUE')) {
@@ -314,6 +316,7 @@ function parseCreate(
 function parseCreateTable(
   cursor: Cursor,
   tables: Map<string, ParsedTable>,
+  droppedTables: ReadonlySet<string>,
   source: string,
 ): void {
   if (cursor.eatWord('IF')) {
@@ -321,6 +324,11 @@ function parseCreateTable(
     cursor.expectWord('EXISTS', 'after IF NOT');
   }
   const name = cursor.identifier('a table name');
+  if (droppedTables.has(name)) {
+    cursor.fail(
+      `table ${name} cannot be re-created after DROP TABLE — table-name reuse is unsupported`,
+    );
+  }
   if (tables.has(name)) {
     cursor.fail(`table ${name} is created twice`);
   }
@@ -506,6 +514,28 @@ function parseAlterTable(
   table.columns.push(def.column);
 }
 
+/** `DROP TABLE [IF EXISTS] name`; table-name reuse remains unsupported. */
+function parseDropTable(
+  cursor: Cursor,
+  tables: Map<string, ParsedTable>,
+  droppedTables: Set<string>,
+): void {
+  cursor.expectWord('TABLE', 'after DROP');
+  let ifExists = false;
+  if (cursor.eatWord('IF')) {
+    cursor.expectWord('EXISTS', 'after IF');
+    ifExists = true;
+  }
+  const name = cursor.identifier('a table name');
+  cursor.expectEnd();
+  if (!tables.has(name)) {
+    if (ifExists) return;
+    cursor.fail(`DROP TABLE ${name}: table does not exist at this point`);
+  }
+  tables.delete(name);
+  droppedTables.add(name);
+}
+
 /**
  * Apply one migration file's SQL to the accumulated table map. Columns
  * accumulate in declaration order — the §2.4 row-codec positional order.
@@ -514,19 +544,22 @@ export function applyMigrationSql(
   tables: Map<string, ParsedTable>,
   sql: string,
   source: string,
+  droppedTables: Set<string> = new Set<string>(),
 ): void {
   for (const tokens of tokenizeStatements(sql, source)) {
     const cursor = new Cursor(tokens, source);
     const head = cursor.next();
     const word = head.kind === 'word' ? head.text.toUpperCase() : '';
     if (word === 'CREATE') {
-      parseCreate(cursor, tables, source);
+      parseCreate(cursor, tables, droppedTables, source);
     } else if (word === 'ALTER') {
       parseAlterTable(cursor, tables);
+    } else if (word === 'DROP') {
+      parseDropTable(cursor, tables, droppedTables);
     } else {
       throw new TypegenError(
         source,
-        `unsupported SQL statement starting with ${JSON.stringify(head.text)} (only CREATE TABLE, CREATE [UNIQUE] INDEX, and ALTER TABLE … ADD COLUMN)`,
+        `unsupported SQL statement starting with ${JSON.stringify(head.text)} (only CREATE TABLE, CREATE [UNIQUE] INDEX, ALTER TABLE … ADD COLUMN, and DROP TABLE)`,
       );
     }
   }