schematic-pg 0.1.0

package/dist/db/model-client.js

@@ -0,0 +1,83 @@
+import { mapPgError } from './errors.js';
+import { QueryBuilder } from './query-builder.js';
+import { mapRow, mapRows } from './row-mapper.js';
+export function createModelClient(model, pool) {
+    const builder = new QueryBuilder(model);
+    async function execute(sql, params) {
+        try {
+            const result = await pool.query(sql, params);
+            return result.rows;
+        }
+        catch (error) {
+            throw mapPgError(error, model.name, model.columnToField);
+        }
+    }
+    return {
+        async create(data) {
+            const query = builder.insert(data);
+            const rows = await execute(query.sql, query.params);
+            return mapRow(rows[0], model);
+        },
+        async findUnique(where) {
+            const query = builder.select({ where, take: 1 });
+            const rows = await execute(query.sql, query.params);
+            return rows[0] ? mapRow(rows[0], model) : null;
+        },
+        async findFirst(args) {
+            const query = builder.select({
+                where: args?.where,
+                orderBy: args?.orderBy,
+                take: 1,
+            });
+            const rows = await execute(query.sql, query.params);
+            return rows[0] ? mapRow(rows[0], model) : null;
+        },
+        async findMany(args) {
+            const query = builder.select({
+                where: args?.where,
+                orderBy: args?.orderBy,
+                take: args?.take,
+                skip: args?.skip,
+            });
+            const rows = await execute(query.sql, query.params);
+            return mapRows(rows, model);
+        },
+        async count(args) {
+            const query = builder.count({ where: args?.where });
+            const rows = await execute(query.sql, query.params);
+            return rows[0]?.count ?? 0;
+        },
+        async update(args) {
+            const query = builder.update({
+                where: args.where,
+                data: args.data,
+            });
+            const rows = await execute(query.sql, query.params);
+            if (!rows[0]) {
+                throw new Error(`Update returned no rows for model ${model.name}`);
+            }
+            return mapRow(rows[0], model);
+        },
+        async updateMany(args) {
+            const query = builder.update({
+                where: args.where,
+                data: args.data,
+            });
+            const rows = await execute(query.sql, query.params);
+            return { count: rows.length };
+        },
+        async delete(where) {
+            const query = builder.delete({ where: where });
+            const rows = await execute(query.sql, query.params);
+            if (!rows[0]) {
+                throw new Error(`Delete returned no rows for model ${model.name}`);
+            }
+            return mapRow(rows[0], model);
+        },
+        async deleteMany(args) {
+            const query = builder.delete({ where: args?.where });
+            const rows = await execute(query.sql, query.params);
+            return { count: rows.length };
+        },
+    };
+}

package/dist/db/model-meta.d.ts

@@ -0,0 +1,36 @@
+import type { Model, Schema, TypeExpr } from '../schema-dsl/ast.js';
+export interface FieldMeta {
+    name: string;
+    columnName: string;
+    type: TypeExpr;
+    optional: boolean;
+    hasDefault: boolean;
+    isId: boolean;
+    isUnique: boolean;
+    isEnum: boolean;
+    isNumeric: boolean;
+    isString: boolean;
+    isBoolean: boolean;
+}
+export interface ModelMetaSnapshot {
+    name: string;
+    tableName: string;
+    quotedTableName: string;
+    primaryKeyFields: string[];
+    fields: FieldMeta[];
+    fieldByName: Record<string, FieldMeta>;
+    columnToField: Record<string, string>;
+}
+export interface ModelMeta {
+    name: string;
+    tableName: string;
+    quotedTableName: string;
+    primaryKeyFields: string[];
+    fields: FieldMeta[];
+    fieldByName: Map<string, FieldMeta>;
+    columnToField: Map<string, string>;
+}
+export declare function buildModelMeta(model: Model, schema: Schema): ModelMeta;
+export declare function buildModelMetaSnapshot(model: Model, schema: Schema): ModelMetaSnapshot;
+export declare function hydrateModelMeta(snapshot: ModelMetaSnapshot): ModelMeta;
+export declare function buildModelMetas(schema: Schema): ModelMeta[];

package/dist/db/model-meta.js

@@ -0,0 +1,57 @@
+import { fieldHasAttribute, getModelNames, getPrimaryKey, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
+import { toColumnName, toTableName } from './utils/naming.js';
+const NUMERIC_TYPES = new Set(['INTEGER', 'SERIAL', 'SMALLINT', 'DECIMAL']);
+const STRING_TYPES = new Set(['UUID', 'VARCHAR', 'TEXT']);
+export function buildModelMeta(model, schema) {
+    return hydrateModelMeta(buildModelMetaSnapshot(model, schema));
+}
+export function buildModelMetaSnapshot(model, schema) {
+    const modelNames = getModelNames(schema);
+    const enumNames = new Set(schema.enums.map((enumDef) => enumDef.name));
+    const primaryKey = getPrimaryKey(model);
+    const primaryKeyFields = primaryKey?.fields ?? ['id'];
+    const storedFields = getStoredFields(model, modelNames);
+    const fields = storedFields.map((field) => toFieldMeta(field, enumNames, primaryKeyFields));
+    const fieldByName = Object.fromEntries(fields.map((field) => [field.name, field]));
+    const columnToField = Object.fromEntries(fields.map((field) => [field.columnName, field.name]));
+    return {
+        name: model.name,
+        tableName: toTableName(model.name),
+        quotedTableName: quoteTable(model.name),
+        primaryKeyFields,
+        fields,
+        fieldByName,
+        columnToField,
+    };
+}
+export function hydrateModelMeta(snapshot) {
+    return {
+        ...snapshot,
+        fieldByName: new Map(Object.entries(snapshot.fieldByName)),
+        columnToField: new Map(Object.entries(snapshot.columnToField)),
+    };
+}
+export function buildModelMetas(schema) {
+    return schema.models.map((model) => buildModelMeta(model, schema));
+}
+function toFieldMeta(field, enumNames, primaryKeyFields) {
+    const typeName = field.type.name;
+    return {
+        name: field.name,
+        columnName: toColumnName(field.name),
+        type: field.type,
+        optional: Boolean(field.type.optional),
+        hasDefault: fieldHasAttribute(field, 'default') || fieldHasAttribute(field, 'id'),
+        isId: primaryKeyFields.includes(field.name) || fieldHasAttribute(field, 'id'),
+        isUnique: fieldHasAttribute(field, 'unique') || fieldHasAttribute(field, 'id'),
+        isEnum: enumNames.has(typeName),
+        isNumeric: NUMERIC_TYPES.has(typeName),
+        isString: STRING_TYPES.has(typeName) || enumNames.has(typeName),
+        isBoolean: typeName === 'BOOLEAN',
+    };
+}
+function quoteTable(modelName) {
+    const tableName = toTableName(modelName);
+    const reserved = new Set(['user', 'order']);
+    return reserved.has(tableName) ? `"${tableName}"` : tableName;
+}

package/dist/db/query-builder.d.ts

@@ -0,0 +1,33 @@
+import type { ModelMeta } from './model-meta.js';
+import { type WhereInput } from './where-translator.js';
+export interface FindArgs {
+    where?: WhereInput;
+    orderBy?: OrderByInput | OrderByInput[];
+    take?: number;
+    skip?: number;
+}
+export interface UpdateArgs {
+    where?: WhereInput;
+    data: Record<string, unknown>;
+}
+export interface DeleteArgs {
+    where?: WhereInput;
+}
+export interface CountArgs {
+    where?: WhereInput;
+}
+export type OrderByInput = Record<string, 'asc' | 'desc'>;
+export interface SqlQuery {
+    sql: string;
+    params: unknown[];
+}
+export declare class QueryBuilder {
+    private readonly model;
+    constructor(model: ModelMeta);
+    insert(data: Record<string, unknown>): SqlQuery;
+    select(args?: FindArgs): SqlQuery;
+    update(args: UpdateArgs): SqlQuery;
+    delete(args?: DeleteArgs): SqlQuery;
+    count(args?: CountArgs): SqlQuery;
+    private buildOrderBy;
+}

package/dist/db/query-builder.js

@@ -0,0 +1,97 @@
+import { WhereTranslator } from './where-translator.js';
+export class QueryBuilder {
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    insert(data) {
+        const entries = this.model.fields.filter((field) => Object.prototype.hasOwnProperty.call(data, field.name));
+        if (entries.length === 0) {
+            throw new Error(`No insertable fields provided for model ${this.model.name}`);
+        }
+        const columns = entries.map((field) => field.columnName);
+        const values = entries.map((field) => data[field.name]);
+        const placeholders = values.map((_, index) => `$${index + 1}`);
+        const sql = `INSERT INTO ${this.model.quotedTableName} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING *`;
+        return { sql, params: values };
+    }
+    select(args = {}) {
+        const whereTranslator = new WhereTranslator(this.model);
+        const whereClause = whereTranslator.translate(args.where);
+        const orderByClause = this.buildOrderBy(args.orderBy);
+        const params = [...whereClause.params];
+        let sql = `SELECT * FROM ${this.model.quotedTableName}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        if (orderByClause) {
+            sql += ` ${orderByClause}`;
+        }
+        if (args.take !== undefined) {
+            params.push(args.take);
+            sql += ` LIMIT $${params.length}`;
+        }
+        if (args.skip !== undefined) {
+            params.push(args.skip);
+            sql += ` OFFSET $${params.length}`;
+        }
+        return { sql, params };
+    }
+    update(args) {
+        const dataEntries = this.model.fields.filter((field) => Object.prototype.hasOwnProperty.call(args.data, field.name));
+        if (dataEntries.length === 0) {
+            throw new Error(`No updatable fields provided for model ${this.model.name}`);
+        }
+        const setClauses = [];
+        const params = [];
+        for (const field of dataEntries) {
+            params.push(args.data[field.name]);
+            setClauses.push(`${field.columnName} = $${params.length}`);
+        }
+        const whereTranslator = new WhereTranslator(this.model, params.length + 1);
+        const whereClause = whereTranslator.translate(args.where);
+        params.push(...whereClause.params);
+        let sql = `UPDATE ${this.model.quotedTableName} SET ${setClauses.join(', ')}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        sql += ' RETURNING *';
+        return { sql, params };
+    }
+    delete(args = {}) {
+        const whereTranslator = new WhereTranslator(this.model);
+        const whereClause = whereTranslator.translate(args.where);
+        let sql = `DELETE FROM ${this.model.quotedTableName}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        sql += ' RETURNING *';
+        return { sql, params: whereClause.params };
+    }
+    count(args = {}) {
+        const whereTranslator = new WhereTranslator(this.model);
+        const whereClause = whereTranslator.translate(args.where);
+        let sql = `SELECT COUNT(*)::int AS count FROM ${this.model.quotedTableName}`;
+        if (whereClause.sql) {
+            sql += ` WHERE ${whereClause.sql}`;
+        }
+        return { sql, params: whereClause.params };
+    }
+    buildOrderBy(orderBy) {
+        if (!orderBy) {
+            return '';
+        }
+        const entries = Array.isArray(orderBy) ? orderBy : [orderBy];
+        const parts = [];
+        for (const entry of entries) {
+            for (const [fieldName, direction] of Object.entries(entry)) {
+                const field = this.model.fieldByName.get(fieldName);
+                if (!field) {
+                    throw new Error(`Unknown orderBy field "${fieldName}" on model ${this.model.name}`);
+                }
+                parts.push(`${field.columnName} ${direction.toUpperCase()}`);
+            }
+        }
+        return parts.length > 0 ? `ORDER BY ${parts.join(', ')}` : '';
+    }
+}

package/dist/db/reset-database.d.ts

@@ -0,0 +1,4 @@
+import type { Pool, PoolClient } from 'pg';
+type Queryable = Pick<Pool, 'query'> | Pick<PoolClient, 'query'>;
+export declare function resetPublicSchema(client: Queryable): Promise<void>;
+export {};

package/dist/db/reset-database.js

@@ -0,0 +1,9 @@
+const RESET_SQL = `
+DROP SCHEMA IF EXISTS public CASCADE;
+CREATE SCHEMA public;
+GRANT ALL ON SCHEMA public TO postgrest;
+GRANT ALL ON SCHEMA public TO public;
+`.trim();
+export async function resetPublicSchema(client) {
+    await client.query(RESET_SQL);
+}

package/dist/db/row-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { ModelMeta } from './model-meta.js';
+export declare function mapRow<T>(row: Record<string, unknown>, model: ModelMeta): T;
+export declare function mapRows<T>(rows: Record<string, unknown>[], model: ModelMeta): T[];

package/dist/db/row-mapper.js

@@ -0,0 +1,41 @@
+import { toCamelCase } from './utils/naming.js';
+export function mapRow(row, model) {
+    const mapped = {};
+    for (const [column, value] of Object.entries(row)) {
+        const fieldName = model.columnToField.get(column) ?? toCamelCase(column);
+        const field = model.fieldByName.get(fieldName);
+        mapped[fieldName] = field ? coerceValue(value, field) : value;
+    }
+    return mapped;
+}
+export function mapRows(rows, model) {
+    return rows.map((row) => mapRow(row, model));
+}
+function coerceValue(value, field) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const typeName = field.type.name;
+    if (typeName === 'TIMESTAMP') {
+        return value instanceof Date ? value : new Date(String(value));
+    }
+    if (typeName === 'BOOLEAN') {
+        return Boolean(value);
+    }
+    if (typeName === 'JSONB') {
+        if (typeof value === 'string') {
+            return JSON.parse(value);
+        }
+        return value;
+    }
+    if (field.type.array && typeName === 'TEXT') {
+        return value;
+    }
+    if (typeName === 'DECIMAL') {
+        return typeof value === 'string' ? value : String(value);
+    }
+    if (field.isNumeric && typeof value === 'string') {
+        return Number(value);
+    }
+    return value;
+}

package/dist/db/schema-state.d.ts

@@ -0,0 +1,7 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export declare function getSnapshotPath(cwd?: string): string;
+export declare function snapshotExists(cwd?: string): boolean;
+export declare function readSnapshotSource(cwd?: string): string | null;
+export declare function readSnapshotSchema(cwd?: string): Schema | null;
+export declare function writeSnapshot(sourcePath: string, cwd?: string): void;
+export declare function ensureSnapshot(schemaPath: string, cwd?: string): void;

package/dist/db/schema-state.js

@@ -0,0 +1,32 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { parse } from '../schema-dsl/index.js';
+const SNAPSHOT_DIR = '.schema-state';
+const SNAPSHOT_FILE = 'app.schema';
+export function getSnapshotPath(cwd = process.cwd()) {
+    return join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
+}
+export function snapshotExists(cwd = process.cwd()) {
+    return existsSync(getSnapshotPath(cwd));
+}
+export function readSnapshotSource(cwd = process.cwd()) {
+    const snapshotPath = getSnapshotPath(cwd);
+    if (!existsSync(snapshotPath)) {
+        return null;
+    }
+    return readFileSync(snapshotPath, 'utf8');
+}
+export function readSnapshotSchema(cwd = process.cwd()) {
+    const source = readSnapshotSource(cwd);
+    return source ? parse(source) : null;
+}
+export function writeSnapshot(sourcePath, cwd = process.cwd()) {
+    const snapshotPath = getSnapshotPath(cwd);
+    mkdirSync(dirname(snapshotPath), { recursive: true });
+    copyFileSync(sourcePath, snapshotPath);
+}
+export function ensureSnapshot(schemaPath, cwd = process.cwd()) {
+    if (!snapshotExists(cwd)) {
+        writeSnapshot(schemaPath, cwd);
+    }
+}

package/dist/db/type-generator.d.ts

@@ -0,0 +1,19 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export declare class TypeGenerator {
+    private readonly schema;
+    constructor(schema: Schema);
+    generate(): string;
+    private generateEnumType;
+    private generateModelTypes;
+    private generateEntityInterface;
+    private generateCreateInput;
+    private generateUpdateInput;
+    private generateWhereInput;
+    private generateOrderByInput;
+    private toTsType;
+    private mapTypeExpr;
+    private isFilterable;
+    private toWhereFieldType;
+}
+export declare function generateDbTypes(schema: Schema): string;
+export declare function getClientExportName(modelName: string): string;

package/dist/db/type-generator.js

@@ -0,0 +1,136 @@
+import { fieldHasAttribute, getModelNames, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
+import { toClientKey } from './utils/naming.js';
+export class TypeGenerator {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    generate() {
+        const enumBlocks = this.schema.enums.map((enumDef) => this.generateEnumType(enumDef.name, enumDef.values));
+        const modelBlocks = this.schema.models.flatMap((model) => this.generateModelTypes(model));
+        return [
+            '// Auto-generated by TypeGenerator. Do not edit manually.',
+            '',
+            ...enumBlocks,
+            ...modelBlocks,
+        ].join('\n');
+    }
+    generateEnumType(name, values) {
+        const union = values.map((value) => `'${value}'`).join(' | ');
+        return `export type ${name} = ${union};\n`;
+    }
+    generateModelTypes(model) {
+        const modelNames = getModelNames(this.schema);
+        const storedFields = getStoredFields(model, modelNames);
+        return [
+            this.generateEntityInterface(model.name, storedFields),
+            this.generateCreateInput(model.name, storedFields),
+            this.generateUpdateInput(model.name, storedFields),
+            this.generateWhereInput(model.name, storedFields),
+            this.generateOrderByInput(model.name, storedFields),
+            '',
+        ];
+    }
+    generateEntityInterface(modelName, fields) {
+        const lines = fields.map((field) => `  ${field.name}: ${this.toTsType(field, 'entity')};`);
+        return `export interface ${modelName} {\n${lines.join('\n')}\n}\n`;
+    }
+    generateCreateInput(modelName, fields) {
+        const lines = fields
+            .filter((field) => !fieldHasAttribute(field, 'id'))
+            .map((field) => {
+            const optionalMarker = field.type.optional || fieldHasAttribute(field, 'default') ? '?' : '';
+            return `  ${field.name}${optionalMarker}: ${this.toTsType(field, 'input')};`;
+        });
+        return `export interface ${modelName}CreateInput {\n${lines.join('\n')}\n}\n`;
+    }
+    generateUpdateInput(modelName, fields) {
+        const lines = fields
+            .filter((field) => !fieldHasAttribute(field, 'id'))
+            .map((field) => `  ${field.name}?: ${this.toTsType(field, 'input')};`);
+        return `export interface ${modelName}UpdateInput {\n${lines.join('\n')}\n}\n`;
+    }
+    generateWhereInput(modelName, fields) {
+        const filterableFields = fields.filter((field) => this.isFilterable(field));
+        const lines = filterableFields.map((field) => `  ${field.name}?: ${this.toWhereFieldType(field)};`);
+        lines.push('  AND?: ' + modelName + 'WhereInput[];');
+        lines.push('  OR?: ' + modelName + 'WhereInput[];');
+        lines.push('  NOT?: ' + modelName + 'WhereInput;');
+        return `export interface ${modelName}WhereInput {\n${lines.join('\n')}\n}\n`;
+    }
+    generateOrderByInput(modelName, fields) {
+        const lines = fields.map((field) => `  ${field.name}?: 'asc' | 'desc';`);
+        return `export interface ${modelName}OrderByInput {\n${lines.join('\n')}\n}\n`;
+    }
+    toTsType(field, mode) {
+        const base = this.mapTypeExpr(field.type);
+        if (field.type.optional) {
+            return `${base} | null`;
+        }
+        if (mode === 'input' && fieldHasAttribute(field, 'default')) {
+            return base;
+        }
+        return base;
+    }
+    mapTypeExpr(type) {
+        const enumType = this.schema.enums.find((enumDef) => enumDef.name === type.name);
+        if (enumType) {
+            return type.name;
+        }
+        if (type.array && type.name === 'TEXT') {
+            return 'string[]';
+        }
+        switch (type.name) {
+            case 'UUID':
+            case 'VARCHAR':
+            case 'TEXT':
+                return 'string';
+            case 'INTEGER':
+            case 'SERIAL':
+            case 'SMALLINT':
+                return 'number';
+            case 'BOOLEAN':
+                return 'boolean';
+            case 'TIMESTAMP':
+                return 'Date';
+            case 'DECIMAL':
+                return 'string';
+            case 'JSONB':
+                return 'Record<string, unknown>';
+            case 'POINT':
+                return 'unknown';
+            default:
+                return 'unknown';
+        }
+    }
+    isFilterable(field) {
+        const typeName = field.type.name;
+        return !this.schema.models.some((model) => model.name === typeName);
+    }
+    toWhereFieldType(field) {
+        const base = this.mapTypeExpr(field.type);
+        const scalar = field.type.optional ? `${base} | null` : base;
+        const filters = [`{ equals: ${scalar} }`];
+        const isStringType = ['UUID', 'VARCHAR', 'TEXT'].includes(field.type.name);
+        const isEnumType = this.schema.enums.some((enumDef) => enumDef.name === field.type.name);
+        if (isStringType) {
+            filters.push(`{ contains: string }`, `{ startsWith: string }`, `{ endsWith: string }`);
+        }
+        if (isEnumType) {
+            filters.push(`{ in: ${base}[] }`);
+        }
+        if (['INTEGER', 'SERIAL', 'SMALLINT', 'DECIMAL'].includes(field.type.name)) {
+            filters.push(`{ gt: ${base} }`, `{ gte: ${base} }`, `{ lt: ${base} }`, `{ lte: ${base} }`);
+        }
+        if (field.type.name === 'BOOLEAN') {
+            return scalar;
+        }
+        return [scalar, ...filters].join(' | ');
+    }
+}
+export function generateDbTypes(schema) {
+    return new TypeGenerator(schema).generate();
+}
+export function getClientExportName(modelName) {
+    return toClientKey(modelName);
+}

package/dist/db/utils/naming.d.ts

@@ -0,0 +1,6 @@
+export { quoteIdentifier, toSnakeCase } from '../../sql-generator/utils/snake-case.js';
+export declare function toCamelCase(value: string): string;
+export declare function pluralize(value: string): string;
+export declare function toTableName(modelName: string): string;
+export declare function toColumnName(fieldName: string): string;
+export declare function toClientKey(modelName: string): string;

package/dist/db/utils/naming.js

@@ -0,0 +1,23 @@
+export { quoteIdentifier, toSnakeCase } from '../../sql-generator/utils/snake-case.js';
+import { toSnakeCase } from '../../sql-generator/utils/snake-case.js';
+export function toCamelCase(value) {
+    return value.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+export function pluralize(value) {
+    if (/[^aeiou]y$/i.test(value)) {
+        return `${value.slice(0, -1)}ies`;
+    }
+    if (/(s|x|z|ch|sh)$/i.test(value)) {
+        return `${value}es`;
+    }
+    return `${value}s`;
+}
+export function toTableName(modelName) {
+    return toSnakeCase(modelName);
+}
+export function toColumnName(fieldName) {
+    return toSnakeCase(fieldName);
+}
+export function toClientKey(modelName) {
+    return modelName.charAt(0).toLowerCase() + modelName.slice(1);
+}

package/dist/db/where-translator.d.ts

@@ -0,0 +1,20 @@
+import type { ModelMeta } from './model-meta.js';
+export type WhereInput = Record<string, unknown>;
+export interface WhereClause {
+    sql: string;
+    params: unknown[];
+}
+export declare class WhereTranslator {
+    private readonly model;
+    private readonly scalarFields;
+    private paramIndex;
+    private readonly startParamIndex;
+    constructor(model: ModelMeta, startParamIndex?: number);
+    translate(where: WhereInput | undefined): WhereClause;
+    getNextParamIndex(): number;
+    private translateLogical;
+    private translateNested;
+    private translateField;
+    private translateOperator;
+    private nextPlaceholder;
+}