@syncular/typegen 0.1.2 → 0.2.0

package/dist/sql.d.ts

@@ -0,0 +1,13 @@
+import type { IrColumn, IrIndex } from './ir.js';
+export interface ParsedTable {
+    readonly name: string;
+    primaryKey: string;
+    readonly columns: IrColumn[];
+    /** Local secondary indexes, in declaration order (CREATE INDEX subset). */
+    readonly indexes: IrIndex[];
+}
+/**
+ * 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;

package/dist/sql.js

@@ -0,0 +1,440 @@
+/**
+ * SQL migration subset parser (REVISE B5).
+ *
+ * Parses exactly the subset v1-style migrations need:
+ *
+ * - `CREATE TABLE [IF NOT EXISTS] name (columns…, [PRIMARY KEY (col)])
+ *   [WITHOUT ROWID]`
+ * - `ALTER TABLE name ADD [COLUMN] coldef`
+ * - `CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table (col [, col…])`
+ * - column defs: `name TYPE [PRIMARY KEY] [NOT NULL] [NULL]
+ *   [DEFAULT literal]`
+ * - `--` and C-style comments
+ *
+ * Anything else — other statements, table constraints, parameterized or
+ * unknown types, DEFAULT expressions, quoted identifiers, composite
+ * primary keys, ASC/DESC or expression index columns, partial (`WHERE`)
+ * indexes — is a hard error naming the unsupported construct.
+ */
+import { TypegenError } from './errors.js';
+/** SQL type keyword → the §2.4 column types. Case-insensitive. */
+const TYPE_MAP = {
+    TEXT: 'string',
+    INTEGER: 'integer',
+    INT: 'integer',
+    BIGINT: 'integer',
+    SMALLINT: 'integer',
+    REAL: 'float',
+    FLOAT: 'float',
+    DOUBLE: 'float',
+    BOOLEAN: 'boolean',
+    BOOL: 'boolean',
+    JSON: 'json',
+    JSONB: 'json',
+    BLOB: 'bytes',
+    BYTEA: 'bytes',
+    // §5.9 tag 7: a stored-as-TEXT column carrying a canonical BlobRef
+    // document. The synthetic keyword designates the semantic type; the local
+    // column is TEXT-shaped like `json`.
+    BLOB_REF: 'blob_ref',
+    BLOBREF: 'blob_ref',
+    // §5.10 tag 8: a stored-as-BLOB column carrying opaque server-merged CRDT
+    // bytes. The synthetic keyword designates the semantic type; crdtType
+    // defaults to the one built-in merger (`yjs-doc`, §5.10.1).
+    CRDT: 'crdt',
+};
+/** 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 DIGIT = /[0-9]/;
+function tokenizeStatements(sql, source) {
+    const statements = [];
+    let current = [];
+    let i = 0;
+    while (i < sql.length) {
+        const ch = sql[i];
+        if (/\s/.test(ch)) {
+            i += 1;
+        }
+        else if (ch === '-' && sql[i + 1] === '-') {
+            const end = sql.indexOf('\n', i);
+            i = end === -1 ? sql.length : end + 1;
+        }
+        else if (ch === '/' && sql[i + 1] === '*') {
+            const end = sql.indexOf('*/', i + 2);
+            if (end === -1)
+                throw new TypegenError(source, 'unterminated comment');
+            i = end + 2;
+        }
+        else if (ch === ';') {
+            if (current.length > 0)
+                statements.push(current);
+            current = [];
+            i += 1;
+        }
+        else if (ch === "'") {
+            let text = '';
+            i += 1;
+            for (;;) {
+                if (i >= sql.length) {
+                    throw new TypegenError(source, 'unterminated string literal');
+                }
+                if (sql[i] === "'") {
+                    if (sql[i + 1] === "'") {
+                        text += "'";
+                        i += 2;
+                    }
+                    else {
+                        i += 1;
+                        break;
+                    }
+                }
+                else {
+                    text += sql[i];
+                    i += 1;
+                }
+            }
+            current.push({ kind: 'string', text });
+        }
+        else if (ch === '"' || ch === '`' || ch === '[') {
+            throw new TypegenError(source, `quoted identifiers are unsupported (found ${JSON.stringify(ch)})`);
+        }
+        else if (WORD_START.test(ch)) {
+            let end = i + 1;
+            while (end < sql.length && WORD_PART.test(sql[end]))
+                end += 1;
+            current.push({ kind: 'word', text: sql.slice(i, end) });
+            i = end;
+        }
+        else if (DIGIT.test(ch)) {
+            let end = i + 1;
+            while (end < sql.length && /[0-9.]/.test(sql[end]))
+                end += 1;
+            current.push({ kind: 'number', text: sql.slice(i, end) });
+            i = end;
+        }
+        else if (ch === '(' || ch === ')' || ch === ',') {
+            current.push({ kind: 'punct', text: ch });
+            i += 1;
+        }
+        else {
+            throw new TypegenError(source, `unsupported SQL syntax: unexpected character ${JSON.stringify(ch)}`);
+        }
+    }
+    if (current.length > 0)
+        statements.push(current);
+    return statements;
+}
+class Cursor {
+    tokens;
+    source;
+    index = 0;
+    constructor(tokens, source) {
+        this.tokens = tokens;
+        this.source = source;
+    }
+    peek() {
+        return this.tokens[this.index];
+    }
+    next() {
+        const token = this.tokens[this.index];
+        if (token === undefined) {
+            throw new TypegenError(this.source, 'unexpected end of SQL statement');
+        }
+        this.index += 1;
+        return token;
+    }
+    /** Consume a word token if it matches (case-insensitive). */
+    eatWord(word) {
+        const token = this.peek();
+        if (token?.kind === 'word' && token.text.toUpperCase() === word) {
+            this.index += 1;
+            return true;
+        }
+        return false;
+    }
+    expectWord(word, context) {
+        const token = this.next();
+        if (token.kind !== 'word' || token.text.toUpperCase() !== word) {
+            throw new TypegenError(this.source, `expected ${word} ${context}, found ${JSON.stringify(token.text)}`);
+        }
+    }
+    expectPunct(punct, context) {
+        const token = this.next();
+        if (token.kind !== 'punct' || token.text !== punct) {
+            throw new TypegenError(this.source, `expected ${JSON.stringify(punct)} ${context}, found ${JSON.stringify(token.text)}`);
+        }
+    }
+    identifier(context) {
+        const token = this.next();
+        if (token.kind !== 'word') {
+            throw new TypegenError(this.source, `expected ${context}, found ${JSON.stringify(token.text)}`);
+        }
+        return token.text;
+    }
+    expectEnd() {
+        const token = this.peek();
+        if (token !== undefined) {
+            throw new TypegenError(this.source, `unsupported trailing SQL ${JSON.stringify(token.text)}`);
+        }
+    }
+    fail(message) {
+        throw new TypegenError(this.source, message);
+    }
+}
+function parseColumnType(cursor, columnName) {
+    const typeWord = cursor.identifier(`a column type for ${columnName}`);
+    if (cursor.peek()?.text === '(') {
+        cursor.fail(`column ${columnName}: parameterized column types are unsupported (${typeWord}(…))`);
+    }
+    const mapped = TYPE_MAP[typeWord.toUpperCase()];
+    if (mapped === undefined) {
+        cursor.fail(`column ${columnName}: unsupported column type ${JSON.stringify(typeWord)}`);
+    }
+    return mapped;
+}
+function parseColumnDef(cursor, allowPrimaryKey) {
+    const name = cursor.identifier('a column name');
+    const type = parseColumnType(cursor, name);
+    let nullable = true;
+    let primaryKey = false;
+    for (;;) {
+        const token = cursor.peek();
+        if (token === undefined || token.kind === 'punct')
+            break;
+        const word = token.text.toUpperCase();
+        if (word === 'PRIMARY') {
+            cursor.next();
+            cursor.expectWord('KEY', 'after PRIMARY');
+            if (!allowPrimaryKey) {
+                cursor.fail(`column ${name}: PRIMARY KEY is not supported on ADD COLUMN`);
+            }
+            primaryKey = true;
+            nullable = false;
+        }
+        else if (word === 'NOT') {
+            cursor.next();
+            cursor.expectWord('NULL', 'after NOT');
+            nullable = false;
+        }
+        else if (word === 'NULL') {
+            cursor.next();
+        }
+        else if (word === 'DEFAULT') {
+            cursor.next();
+            const value = cursor.next();
+            if (value.kind === 'punct') {
+                cursor.fail(`column ${name}: DEFAULT expressions are unsupported (only literals)`);
+            }
+            // Literal defaults are accepted and ignored: typegen extracts the
+            // schema shape; running migrations is the host's job.
+        }
+        else {
+            cursor.fail(`column ${name}: unsupported column constraint ${JSON.stringify(token.text)}`);
+        }
+    }
+    if (primaryKey)
+        nullable = false;
+    // §5.10.1: a crdt column carries a crdtType (default `yjs-doc`).
+    const column = type === 'crdt'
+        ? { name, type, nullable, crdtType: DEFAULT_CRDT_TYPE }
+        : { name, type, nullable };
+    return { column, primaryKey };
+}
+/**
+ * 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) {
+    if (cursor.eatWord('TABLE')) {
+        parseCreateTable(cursor, tables, source);
+        return;
+    }
+    if (cursor.eatWord('UNIQUE')) {
+        cursor.expectWord('INDEX', 'after CREATE UNIQUE');
+        parseCreateIndex(cursor, tables, true);
+        return;
+    }
+    if (cursor.eatWord('INDEX')) {
+        parseCreateIndex(cursor, tables, false);
+        return;
+    }
+    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) {
+    if (cursor.eatWord('IF')) {
+        cursor.expectWord('NOT', 'after IF');
+        cursor.expectWord('EXISTS', 'after IF NOT');
+    }
+    const name = cursor.identifier('a table name');
+    if (tables.has(name)) {
+        cursor.fail(`table ${name} is created twice`);
+    }
+    cursor.expectPunct('(', `after CREATE TABLE ${name}`);
+    const columns = [];
+    const primaryKeys = [];
+    for (;;) {
+        const head = cursor.peek();
+        if (head?.kind === 'word') {
+            const word = head.text.toUpperCase();
+            if (word === 'PRIMARY') {
+                cursor.next();
+                cursor.expectWord('KEY', 'after PRIMARY');
+                cursor.expectPunct('(', 'after PRIMARY KEY');
+                primaryKeys.push(cursor.identifier('a primary-key column name'));
+                if (cursor.peek()?.text === ',') {
+                    cursor.fail(`table ${name}: composite primary keys are unsupported`);
+                }
+                cursor.expectPunct(')', 'after the PRIMARY KEY column');
+            }
+            else if (word === 'FOREIGN' ||
+                word === 'UNIQUE' ||
+                word === 'CHECK' ||
+                word === 'CONSTRAINT') {
+                cursor.fail(`table ${name}: unsupported table constraint ${JSON.stringify(head.text)}`);
+            }
+            else {
+                const def = parseColumnDef(cursor, true);
+                if (columns.some((c) => c.name === def.column.name)) {
+                    cursor.fail(`table ${name}: duplicate column ${JSON.stringify(def.column.name)}`);
+                }
+                columns.push(def.column);
+                if (def.primaryKey)
+                    primaryKeys.push(def.column.name);
+            }
+        }
+        else {
+            cursor.fail(`table ${name}: expected a column definition`);
+        }
+        const sep = cursor.next();
+        if (sep.kind === 'punct' && sep.text === ',')
+            continue;
+        if (sep.kind === 'punct' && sep.text === ')')
+            break;
+        cursor.fail(`table ${name}: expected "," or ")", found ${JSON.stringify(sep.text)}`);
+    }
+    if (cursor.eatWord('WITHOUT')) {
+        cursor.expectWord('ROWID', 'after WITHOUT');
+    }
+    cursor.expectEnd();
+    if (primaryKeys.length === 0) {
+        throw new TypegenError(source, `table ${name} declares no primary key`);
+    }
+    if (primaryKeys.length > 1) {
+        throw new TypegenError(source, `table ${name}: composite primary keys are unsupported (${primaryKeys.join(', ')})`);
+    }
+    const primaryKey = primaryKeys[0];
+    const pkColumn = columns.find((c) => c.name === primaryKey);
+    if (pkColumn === undefined) {
+        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, { name, primaryKey, columns: finalColumns, indexes: [] });
+}
+/**
+ * `CREATE [UNIQUE] INDEX [IF NOT EXISTS] name ON table (col [, col…])`.
+ * The `UNIQUE` keyword is already consumed by the dispatcher (it precedes
+ * `INDEX`), so `unique` is passed in. The subset keeps the column list to
+ * bare column names of the target table: ASC/DESC, expressions, and a `WHERE`
+ * (partial index) clause are hard errors naming the construct. Index names
+ * are unique per accumulated schema.
+ */
+function parseCreateIndex(cursor, tables, unique) {
+    // `INDEX` already matched by the dispatcher.
+    if (cursor.eatWord('IF')) {
+        cursor.expectWord('NOT', 'after IF');
+        cursor.expectWord('EXISTS', 'after IF NOT');
+    }
+    const name = cursor.identifier('an index name');
+    for (const table of tables.values()) {
+        if (table.indexes.some((i) => i.name === name)) {
+            cursor.fail(`index ${name} is created twice`);
+        }
+    }
+    cursor.expectWord('ON', `after CREATE INDEX ${name}`);
+    const tableName = cursor.identifier('a table name');
+    const table = tables.get(tableName);
+    if (table === undefined) {
+        cursor.fail(`CREATE INDEX ${name}: table ${tableName} does not exist at this point`);
+    }
+    cursor.expectPunct('(', `after CREATE INDEX ${name} ON ${tableName}`);
+    const columns = [];
+    for (;;) {
+        const col = cursor.identifier(`an index column for ${name}`);
+        // Reject ASC/DESC and any expression tail: the IR stores bare column names
+        // only, so accepting a direction would silently drop it. A following word
+        // (not "," or ")") is such an unsupported construct.
+        const after = cursor.peek();
+        if (after !== undefined &&
+            !(after.kind === 'punct' && (after.text === ',' || after.text === ')'))) {
+            const dir = after.text.toUpperCase();
+            if (dir === 'ASC' || dir === 'DESC') {
+                cursor.fail(`index ${name}: ASC/DESC index columns are unsupported (found ${JSON.stringify(after.text)} after ${JSON.stringify(col)})`);
+            }
+            cursor.fail(`index ${name}: expression index columns are unsupported (found ${JSON.stringify(after.text)} after ${JSON.stringify(col)})`);
+        }
+        if (table.columns.every((c) => c.name !== col)) {
+            cursor.fail(`index ${name}: column ${JSON.stringify(col)} does not exist on table ${tableName}`);
+        }
+        if (columns.includes(col)) {
+            cursor.fail(`index ${name}: column ${JSON.stringify(col)} appears twice`);
+        }
+        columns.push(col);
+        const sep = cursor.next();
+        if (sep.kind === 'punct' && sep.text === ',')
+            continue;
+        if (sep.kind === 'punct' && sep.text === ')')
+            break;
+        cursor.fail(`index ${name}: expected "," or ")", found ${JSON.stringify(sep.text)}`);
+    }
+    // A trailing token here is a partial-index `WHERE`, `COLLATE`, etc.
+    const trailing = cursor.peek();
+    if (trailing !== undefined) {
+        if (trailing.kind === 'word' && trailing.text.toUpperCase() === 'WHERE') {
+            cursor.fail(`index ${name}: partial indexes (WHERE …) are unsupported`);
+        }
+        cursor.fail(`index ${name}: unsupported trailing SQL ${JSON.stringify(trailing.text)}`);
+    }
+    table.indexes.push({ name, columns, unique });
+}
+function parseAlterTable(cursor, tables) {
+    cursor.expectWord('TABLE', 'after ALTER');
+    const name = cursor.identifier('a table name');
+    const table = tables.get(name);
+    if (table === undefined) {
+        cursor.fail(`ALTER TABLE ${name}: table does not exist at this point`);
+    }
+    const action = cursor.identifier('an ALTER TABLE action');
+    if (action.toUpperCase() !== 'ADD') {
+        cursor.fail(`ALTER TABLE ${name}: unsupported action ${JSON.stringify(action)} (only ADD COLUMN)`);
+    }
+    cursor.eatWord('COLUMN');
+    const def = parseColumnDef(cursor, false);
+    cursor.expectEnd();
+    if (table.columns.some((c) => c.name === def.column.name)) {
+        cursor.fail(`ALTER TABLE ${name}: duplicate column ${JSON.stringify(def.column.name)}`);
+    }
+    table.columns.push(def.column);
+}
+/**
+ * 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) {
+    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);
+        }
+        else if (word === 'ALTER') {
+            parseAlterTable(cursor, tables);
+        }
+        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)`);
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.1.2",
-  "description": "TypeScript type generator for Syncular schemas",
+  "version": "0.2.0",
+  "description": "Syncular schema-to-TypeScript type generator and the `syncular` CLI",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
   "homepage": "https://syncular.dev",
@@ -18,57 +18,37 @@
     "offline-first",
     "realtime",
     "database",
-    "typescript",
-    "codegen",
     "typescript"
   ],
-  "private": false,
+  "type": "module",
+  "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
-  "type": "module",
   "bin": {
-    "syncular-typegen": "./src/cli.ts"
+    "syncular": "./dist/cli.js"
   },
   "exports": {
     ".": {
       "bun": "./src/index.ts",
+      "browser": "./src/index.ts",
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
       }
     }
   },
-  "scripts": {
-    "test": "bun test --pass-with-no-tests",
-    "tsgo": "tsgo --noEmit",
-    "build": "tsgo",
-    "release": "syncular-publish"
-  },
-  "dependencies": {
-    "@electric-sql/pglite": "^0.3.15",
-    "@syncular/migrations": "0.1.1",
-    "better-sqlite3": "^12.8.0",
-    "kysely-bun-sqlite": "^0.4.0",
-    "kysely-pglite-dialect": "^1.2.0"
-  },
-  "peerDependencies": {
-    "kysely": "^0.28.0"
-  },
-  "devDependencies": {
-    "@syncular/config": "0.0.0",
-    "@types/better-sqlite3": "^7.6.13",
-    "kysely": "*"
-  },
   "files": [
     "dist",
     "src",
+    "README.md",
     "!src/**/*.test.ts",
     "!src/**/*.test.tsx",
-    "!src/**/__tests__/**",
-    "!dist/**/*.test.*",
-    "!dist/**/__tests__/**",
-    "!test/**",
-    "!tests/**"
-  ]
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts"
+  ],
+  "devDependencies": {
+    "@syncular/core": "0.2.0",
+    "@syncular/server": "0.2.0"
+  }
 }