schematic-pg 0.1.0

package/dist/sql-generator/utils/ast-helpers.js

@@ -0,0 +1,252 @@
+import { formatDefaultValue, serializeValue } from './value-formatter.js';
+import { mapColumnType } from './type-mapper.js';
+import { toSnakeCase, toTableName } from './snake-case.js';
+export function getModelNames(schema) {
+    return new Set(schema.models.map((model) => model.name));
+}
+export function getEnumNames(schema) {
+    return new Set(schema.enums.map((enumDef) => enumDef.name));
+}
+export function isStoredField(field, modelNames) {
+    return !modelNames.has(field.type.name);
+}
+export function getStoredFields(model, modelNames) {
+    return model.fields.filter((field) => isStoredField(field, modelNames));
+}
+export function getFieldAttribute(field, name) {
+    return field.attributes.find((attr) => attr.name === name);
+}
+export function getModelAttribute(model, name) {
+    return model.attributes.find((attr) => attr.name === name);
+}
+export function getDirective(model, name) {
+    return model.directives.find((directive) => directive.name === name);
+}
+export function getDirectives(model, name) {
+    return model.directives.filter((directive) => directive.name === name);
+}
+export function assertKeyValueArgs(args) {
+    if (!args || args.kind !== 'KeyValueArgs') {
+        throw new Error('Expected KeyValueArgs');
+    }
+    return args;
+}
+export function getKvPair(args, key) {
+    const pair = args.pairs.find((item) => item.key === key);
+    if (!pair) {
+        throw new Error(`Missing key "${key}" in KeyValueArgs`);
+    }
+    return pair;
+}
+export function getOptionalKvPair(args, key) {
+    return args.pairs.find((item) => item.key === key);
+}
+export function getIdentifierNames(value) {
+    if (value.kind !== 'ArrayLiteral') {
+        throw new Error('Expected ArrayLiteral');
+    }
+    return value.elements.map((element) => {
+        if (element.kind !== 'Identifier') {
+            throw new Error('Expected Identifier in array');
+        }
+        return element.name;
+    });
+}
+export function fieldHasAttribute(field, name) {
+    return field.attributes.some((attr) => attr.name === name);
+}
+export function getPrimaryKey(model) {
+    const compositeDirective = getDirective(model, 'id');
+    if (compositeDirective?.args?.kind === 'KeyValueArgs') {
+        const fields = getIdentifierNames(getKvPair(compositeDirective.args, 'fields').value);
+        return { fields, composite: fields.length > 1 };
+    }
+    const modelLevelId = getModelAttribute(model, 'id');
+    if (modelLevelId) {
+        const idField = model.fields.find((field) => field.name === 'id');
+        if (idField) {
+            return { fields: [idField.name], composite: false };
+        }
+    }
+    const idFields = model.fields.filter((field) => fieldHasAttribute(field, 'id')).map((field) => field.name);
+    if (idFields.length === 1) {
+        return { fields: idFields, composite: false };
+    }
+    if (idFields.length > 1) {
+        return { fields: idFields, composite: true };
+    }
+    return undefined;
+}
+export function getDefaultExpression(field, enumNames) {
+    const defaultAttr = getFieldAttribute(field, 'default');
+    if (!defaultAttr?.args || defaultAttr.args.kind !== 'ExpressionArgs') {
+        return undefined;
+    }
+    const [expression] = defaultAttr.args.expressions;
+    if (!expression) {
+        return undefined;
+    }
+    return formatDefaultValue(expression, field.type, enumNames);
+}
+export function collectValidationComments(field) {
+    const comments = [];
+    const regexAttr = getFieldAttribute(field, 'regex');
+    if (regexAttr?.args?.kind === 'KeyValueArgs') {
+        const pattern = getOptionalKvPair(regexAttr.args, 'pattern');
+        const message = getOptionalKvPair(regexAttr.args, 'message');
+        const patternValue = pattern?.value.kind === 'StringLiteral' ? `'${pattern.value.value}'` : 'unknown';
+        const messageValue = message?.value.kind === 'StringLiteral' ? `'${message.value.value}'` : 'unknown';
+        comments.push(`-- @regex: pattern = ${patternValue}, message = ${messageValue}`);
+    }
+    const rangeAttr = getFieldAttribute(field, 'range');
+    if (rangeAttr?.args?.kind === 'KeyValueArgs') {
+        const min = getOptionalKvPair(rangeAttr.args, 'min');
+        const max = getOptionalKvPair(rangeAttr.args, 'max');
+        const message = getOptionalKvPair(rangeAttr.args, 'message');
+        const minValue = min?.value.kind === 'NumberLiteral' ? String(min.value.value) : 'unknown';
+        const maxValue = max?.value.kind === 'NumberLiteral' ? String(max.value.value) : 'unknown';
+        const messageValue = message?.value.kind === 'StringLiteral' ? `'${message.value.value}'` : 'unknown';
+        comments.push(`-- @range: min = ${minValue}, max = ${maxValue}, message = ${messageValue}`);
+    }
+    return comments;
+}
+export function mapReferentialAction(value) {
+    if (!value || value.kind !== 'Identifier') {
+        return undefined;
+    }
+    return value.name.replace(/_/g, ' ');
+}
+export function collectForeignKeys(schema) {
+    const modelNames = getModelNames(schema);
+    const foreignKeys = [];
+    for (const model of schema.models) {
+        for (const field of model.fields) {
+            if (!modelNames.has(field.type.name)) {
+                continue;
+            }
+            const relation = getFieldAttribute(field, 'relation');
+            if (!relation?.args || relation.args.kind !== 'KeyValueArgs') {
+                continue;
+            }
+            const fieldsPair = getOptionalKvPair(relation.args, 'fields');
+            const referencesPair = getOptionalKvPair(relation.args, 'references');
+            if (!fieldsPair || !referencesPair) {
+                continue;
+            }
+            const sourceColumns = getIdentifierNames(fieldsPair.value);
+            const targetColumns = getIdentifierNames(referencesPair.value);
+            const onDelete = mapReferentialAction(getOptionalKvPair(relation.args, 'onDelete')?.value);
+            const onUpdate = mapReferentialAction(getOptionalKvPair(relation.args, 'onUpdate')?.value);
+            foreignKeys.push({
+                sourceModel: model.name,
+                sourceTable: toTableName(model.name),
+                sourceColumns: sourceColumns.map(toSnakeCase),
+                targetModel: field.type.name,
+                targetTable: toTableName(field.type.name),
+                targetColumns: targetColumns.map(toSnakeCase),
+                onDelete,
+                onUpdate,
+            });
+        }
+    }
+    return foreignKeys;
+}
+export function serializeColumnType(type, enumNames) {
+    return mapColumnType(type, enumNames);
+}
+export function serializeDefault(field, enumNames) {
+    const defaultAttr = getFieldAttribute(field, 'default');
+    if (!defaultAttr?.args || defaultAttr.args.kind !== 'ExpressionArgs') {
+        return undefined;
+    }
+    const [expression] = defaultAttr.args.expressions;
+    if (!expression) {
+        return undefined;
+    }
+    return serializeValue(expression);
+}
+export function getFieldSnakeNameMap(model, modelNames) {
+    const map = new Map();
+    for (const field of getStoredFields(model, modelNames)) {
+        map.set(field.name, toSnakeCase(field.name));
+    }
+    return map;
+}
+export function transformWhereClause(where, fieldNameMap) {
+    let transformed = where;
+    const sortedFieldNames = [...fieldNameMap.keys()].sort((a, b) => b.length - a.length);
+    for (const fieldName of sortedFieldNames) {
+        const snakeName = fieldNameMap.get(fieldName);
+        const pattern = new RegExp(`\\b${escapeRegExp(fieldName)}\\b`, 'g');
+        transformed = transformed.replace(pattern, snakeName);
+    }
+    return transformed;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function serializeForeignKey(foreignKey) {
+    return JSON.stringify({
+        sourceTable: foreignKey.sourceTable,
+        sourceColumns: foreignKey.sourceColumns,
+        targetTable: foreignKey.targetTable,
+        targetColumns: foreignKey.targetColumns,
+        onDelete: foreignKey.onDelete,
+        onUpdate: foreignKey.onUpdate,
+    });
+}
+export function parseForeignKeySignature(signature) {
+    const parsed = JSON.parse(signature);
+    return {
+        sourceModel: '',
+        targetModel: '',
+        ...parsed,
+    };
+}
+export function normalizeIndexDirective(directive, model, modelNames) {
+    const args = assertKeyValueArgs(directive.args);
+    const fields = getIdentifierNames(getKvPair(args, 'fields').value);
+    const wherePair = getOptionalKvPair(args, 'where');
+    const uniquePair = getOptionalKvPair(args, 'unique');
+    const namePair = getOptionalKvPair(args, 'name');
+    const typePair = getOptionalKvPair(args, 'type');
+    const fieldNameMap = getFieldSnakeNameMap(model, modelNames);
+    return {
+        fields,
+        where: wherePair?.value.kind === 'StringLiteral'
+            ? transformWhereClause(wherePair.value.value, fieldNameMap)
+            : undefined,
+        unique: uniquePair?.value.kind === 'BooleanLiteral' ? uniquePair.value.value : undefined,
+        name: namePair?.value.kind === 'StringLiteral' ? namePair.value.value : undefined,
+        type: typePair?.value.kind === 'Identifier' ? typePair.value.name : undefined,
+    };
+}
+export function normalizeTriggerDirective(directive) {
+    const args = assertKeyValueArgs(directive.args);
+    const timing = getKvPair(args, 'timing').value;
+    const event = getKvPair(args, 'event').value;
+    const execute = getKvPair(args, 'execute').value;
+    const levelPair = getOptionalKvPair(args, 'level');
+    if (timing.kind !== 'Identifier' || event.kind !== 'Identifier') {
+        throw new Error('Trigger timing and event must be identifiers');
+    }
+    if (execute.kind !== 'TripleStringLiteral') {
+        throw new Error('Trigger execute must be a triple-quoted string');
+    }
+    const levelValue = levelPair?.value.kind === 'Identifier' ? levelPair.value.name.toUpperCase() : 'ROW';
+    return {
+        timing: timing.name.toUpperCase(),
+        event: event.name.toUpperCase(),
+        level: levelValue,
+        execute: execute.value.trim(),
+    };
+}
+export function resolveTriggerNames(model, timing, event) {
+    const timingValue = timing.toLowerCase();
+    const eventValue = event.toLowerCase();
+    const baseName = `${toTableName(model.name)}_${timingValue}_${eventValue}`;
+    return {
+        functionName: `${baseName}_trigger_func`,
+        triggerName: `${baseName}_trigger`,
+    };
+}

package/dist/sql-generator/utils/format.d.ts

@@ -0,0 +1,2 @@
+export declare function joinSection(header: string, statements: string[]): string;
+export declare function formatCreateTable(tableName: string, blocks: string[][]): string;

package/dist/sql-generator/utils/format.js

@@ -0,0 +1,21 @@
+export function joinSection(header, statements) {
+    if (statements.length === 0) {
+        return `-- ${header}\n`;
+    }
+    return `-- ${header}\n\n${statements.join('\n\n')}\n`;
+}
+export function formatCreateTable(tableName, blocks) {
+    const renderedBlocks = blocks.map((lines, blockIndex) => {
+        const isLastBlock = blockIndex === blocks.length - 1;
+        const renderedLines = lines.map((line, lineIndex) => {
+            const prefix = '  ';
+            if (line.startsWith('--')) {
+                return `${prefix}${line}`;
+            }
+            const needsComma = lineIndex === 0 && !isLastBlock;
+            return `${prefix}${line}${needsComma ? ',' : ''}`;
+        });
+        return renderedLines.join('\n');
+    });
+    return `CREATE TABLE ${tableName} (\n${renderedBlocks.join('\n')}\n);`;
+}

package/dist/sql-generator/utils/snake-case.d.ts

@@ -0,0 +1,3 @@
+export declare function toSnakeCase(str: string): string;
+export declare function toTableName(modelName: string): string;
+export declare function quoteIdentifier(name: string): string;

package/dist/sql-generator/utils/snake-case.js

@@ -0,0 +1,96 @@
+const POSTGRES_RESERVED_WORDS = new Set([
+    'all',
+    'analyse',
+    'analyze',
+    'and',
+    'any',
+    'array',
+    'as',
+    'asc',
+    'asymmetric',
+    'both',
+    'case',
+    'cast',
+    'check',
+    'collate',
+    'column',
+    'constraint',
+    'create',
+    'current_catalog',
+    'current_date',
+    'current_role',
+    'current_time',
+    'current_timestamp',
+    'current_user',
+    'default',
+    'deferrable',
+    'desc',
+    'distinct',
+    'do',
+    'else',
+    'end',
+    'except',
+    'false',
+    'fetch',
+    'for',
+    'foreign',
+    'from',
+    'grant',
+    'group',
+    'having',
+    'in',
+    'initially',
+    'intersect',
+    'into',
+    'leading',
+    'limit',
+    'localtime',
+    'localtimestamp',
+    'not',
+    'null',
+    'offset',
+    'on',
+    'only',
+    'or',
+    'order',
+    'placing',
+    'primary',
+    'references',
+    'returning',
+    'select',
+    'session_user',
+    'some',
+    'symmetric',
+    'table',
+    'then',
+    'to',
+    'trailing',
+    'true',
+    'union',
+    'unique',
+    'user',
+    'using',
+    'variadic',
+    'when',
+    'where',
+    'window',
+    'with',
+]);
+export function toSnakeCase(str) {
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+export function toTableName(modelName) {
+    return toSnakeCase(modelName);
+}
+export function quoteIdentifier(name) {
+    if (POSTGRES_RESERVED_WORDS.has(name.toLowerCase())) {
+        return `"${name.replace(/"/g, '""')}"`;
+    }
+    if (/^[a-z_][a-z0-9_]*$/.test(name)) {
+        return name;
+    }
+    return `"${name.replace(/"/g, '""')}"`;
+}

package/dist/sql-generator/utils/type-mapper.d.ts

@@ -0,0 +1,2 @@
+import type { TypeExpr } from '../../schema-dsl/ast.js';
+export declare function mapColumnType(type: TypeExpr, enumNames: Set<string>): string;

package/dist/sql-generator/utils/type-mapper.js

@@ -0,0 +1,39 @@
+import { toSnakeCase } from './snake-case.js';
+const PRIMITIVE_TYPES = new Set([
+    'UUID',
+    'TEXT',
+    'INTEGER',
+    'SERIAL',
+    'BOOLEAN',
+    'JSONB',
+    'POINT',
+    'SMALLINT',
+    'VARCHAR',
+    'DECIMAL',
+    'TIMESTAMP',
+]);
+export function mapColumnType(type, enumNames) {
+    const baseType = mapBaseType(type, enumNames);
+    return type.array ? `${baseType}[]` : baseType;
+}
+function mapBaseType(type, enumNames) {
+    const { name } = type;
+    if (enumNames.has(name)) {
+        return toSnakeCase(name);
+    }
+    if (name === 'TIMESTAMP') {
+        return 'TIMESTAMP WITH TIME ZONE';
+    }
+    if (name === 'VARCHAR' && type.args?.length) {
+        const length = type.args.map((arg) => arg.value).join(', ');
+        return `VARCHAR(${length})`;
+    }
+    if (name === 'DECIMAL' && type.args?.length) {
+        const args = type.args.map((arg) => arg.value).join(', ');
+        return `DECIMAL(${args})`;
+    }
+    if (PRIMITIVE_TYPES.has(name)) {
+        return name;
+    }
+    return name;
+}

package/dist/sql-generator/utils/value-formatter.d.ts

@@ -0,0 +1,4 @@
+import type { TypeExpr, Value } from '../../schema-dsl/ast.js';
+export declare function formatDefaultValue(value: Value, columnType: TypeExpr, enumNames: Set<string>): string;
+export declare function escapeSqlString(value: string): string;
+export declare function serializeValue(value: Value): string;

package/dist/sql-generator/utils/value-formatter.js

@@ -0,0 +1,41 @@
+export function formatDefaultValue(value, columnType, enumNames) {
+    switch (value.kind) {
+        case 'CallExpression': {
+            const args = value.args.map((arg) => formatValueLiteral(arg, enumNames)).join(', ');
+            return args.length > 0 ? `${value.callee}(${args})` : `${value.callee}()`;
+        }
+        case 'BooleanLiteral':
+            return value.value ? 'true' : 'false';
+        case 'NumberLiteral':
+            return String(value.value);
+        case 'Identifier':
+            if (enumNames.has(columnType.name)) {
+                return `'${escapeSqlString(value.name)}'`;
+            }
+            return value.name;
+        case 'StringLiteral':
+            return `'${escapeSqlString(value.value)}'`;
+        default:
+            throw new Error(`Unsupported default value kind: ${value.kind}`);
+    }
+}
+function formatValueLiteral(value, enumNames) {
+    switch (value.kind) {
+        case 'BooleanLiteral':
+            return value.value ? 'true' : 'false';
+        case 'NumberLiteral':
+            return String(value.value);
+        case 'Identifier':
+            return value.name;
+        case 'StringLiteral':
+            return `'${escapeSqlString(value.value)}'`;
+        default:
+            throw new Error(`Unsupported default argument kind: ${value.kind}`);
+    }
+}
+export function escapeSqlString(value) {
+    return value.replace(/'/g, "''");
+}
+export function serializeValue(value) {
+    return JSON.stringify(value);
+}

package/dist/types/generated-db.stub.d.ts

@@ -0,0 +1,2 @@
+export type DbClient = Record<string, unknown>;
+export declare function createDbClient(_pool: unknown): DbClient;

package/dist/types/generated-db.stub.js

@@ -0,0 +1,3 @@
+export function createDbClient(_pool) {
+    return {};
+}

package/dist/types/generated-policies.stub.d.ts

@@ -0,0 +1,7 @@
+export type PolicyOperation = 'select' | 'insert' | 'update' | 'delete';
+export interface NormalizedPolicy {
+    role: string;
+    operations: PolicyOperation[] | 'all';
+    where?: string;
+}
+export declare const POLICIES: Record<string, NormalizedPolicy[]>;

package/dist/types/generated-policies.stub.js

@@ -0,0 +1 @@
+export const POLICIES = {};

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "schematic-pg",
+  "version": "0.1.0",
+  "description": "Single-file backend framework for PostgreSQL and Node.js",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tawsbob/postgrest.js.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "schematic-pg": "./dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "workspaces": [
+    "editors/vscode",
+    "editors/language-server"
+  ],
+  "imports": {
+    "generated/db.js": "./generated/db.js",
+    "generated/policies.js": "./generated/policies.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schema-dsl": {
+      "types": "./dist/schema-dsl/index.d.ts",
+      "import": "./dist/schema-dsl/index.js"
+    },
+    "./api/*": {
+      "types": "./dist/api/*.d.ts",
+      "import": "./dist/api/*.js"
+    },
+    "./db/*": {
+      "types": "./dist/db/*.d.ts",
+      "import": "./dist/db/*.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "parse": "tsx src/schema-dsl/cli.ts",
+    "tokenize": "tsx src/schema-dsl/cli.ts --tokens",
+    "generate": "tsx src/cli.ts generate",
+    "generate:client": "tsx src/cli.ts generate:client",
+    "generate:api": "tsx src/cli.ts generate:api",
+    "dev:api": "tsx src/cli.ts dev",
+    "setup:env": "test -f .env || cp .env.example .env",
+    "db:ping": "tsx src/cli.ts db:ping",
+    "db:bootstrap": "tsx src/cli.ts db:bootstrap",
+    "db:diff": "tsx src/cli.ts db:diff",
+    "db:migrate": "tsx src/cli.ts db:migrate",
+    "db:migrate:status": "tsx src/cli.ts db:migrate:status",
+    "build:lsp": "npm run build --workspace=@schematic-pg/schema-dsl-language-server",
+    "build:extension": "npm run vscode:prepublish --workspace=schematic-pg-schema-dsl-vscode && npm run package --workspace=schematic-pg-schema-dsl-vscode",
+    "test": "node --import tsx --test $(find src editors/language-server -path '*/__tests__/*.test.ts' ! -name '*.integration.test.ts')",
+    "test:integration": "npm run setup:env && docker compose up -d --wait && npm run generate:client && npm run generate:api && JWT_SECRET=integration-test-secret node --import tsx --test --test-concurrency=1 'src/**/__tests__/**/*.integration.test.ts'",
+    "docker:up": "docker compose up -d",
+    "docker:down": "docker compose down",
+    "docker:logs": "docker compose logs -f postgres",
+    "docker:reset": "docker compose down -v && rm -rf docker_data/postgres && docker compose up -d"
+  },
+  "dependencies": {
+    "@hono/node-server": "^2.0.6",
+    "@hono/zod-validator": "^0.8.0",
+    "hono": "^4.12.27",
+    "pg": "^8.22.0",
+    "tsx": "^4.19.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "@types/pg": "^8.11.14",
+    "typescript": "^5.8.3"
+  }
+}