schematic-pg 0.1.18 → 0.1.20

package/README.md

@@ -11,7 +11,7 @@
 
 `app.schema` is the source of truth. From it, schematic-pg generates PostgreSQL DDL, a type-safe DB client, REST routes, Zod validators, and ACL policies.
 
-A schema file always has three sections, in this order: `extensions`, `enums`, `models`.
+A schema file has three required sections, in this order: `extensions`, `enums`, `models`. An optional `functions` section may follow.
 
 ```ts
 extensions {
@@ -376,6 +376,66 @@ model User {
 | `level` | `ROW`, `STATEMENT` | `ROW` |
 | `execute` | Triple-quoted PL/pgSQL | — |
 
+### Functions
+
+Optional section after `models`. Each `function` becomes a PostgreSQL `CREATE OR REPLACE FUNCTION`. Names and parameters are converted to `snake_case` (`getUserBalance` → `get_user_balance`, `userId` → `user_id`). The `execute` body is copied as-is — use those SQL names inside it, not camelCase.
+
+```ts
+functions {
+  function getUserBalance(userId: UUID): INTEGER {
+    language: sql
+    volatility: STABLE
+    execute: """
+      SELECT balance FROM "user" WHERE id = user_id
+    """
+  }
+
+  function searchProducts(query: TEXT): TABLE(id: UUID, name: TEXT, price: DECIMAL) {
+    language: sql
+    volatility: STABLE
+    execute: """
+      SELECT id, name, price FROM product
+      WHERE name ILIKE '%' || query || '%'
+    """
+  }
+
+  function setUpdatedAt(): TRIGGER {
+    language: plpgsql
+    execute: """
+      NEW.updated_at = now();
+      RETURN NEW;
+    """
+  }
+}
+```
+
+| Argument | Values | Default |
+|----------|--------|---------|
+| `language` | `sql`, `plpgsql` | `sql` |
+| `volatility` | `VOLATILE`, `STABLE`, `IMMUTABLE` | `VOLATILE` |
+| `security` | `INVOKER`, `DEFINER` | `INVOKER` |
+| `execute` | Triple-quoted SQL / PL/pgSQL | required |
+
+Return types are PostgreSQL types (`INTEGER`, `UUID`, `JSONB`, …), `TRIGGER`, `VOID`, or `TABLE(col: Type, …)` for set-returning functions. Body keys may be newline-separated or comma-separated. TABLE column names must be unique and must not collide with input parameter names.
+
+`language: plpgsql` wraps the body in `BEGIN` / `END` unless it already starts with `DECLARE` or `BEGIN`. Function names must be unique in the schema.
+
+`db:diff` treats body, language, volatility, and security changes as `CREATE OR REPLACE`. Argument or return-type changes (including TABLE column changes) drop the old function, then create the new one.
+
+Functions are database objects only in this release — they are not REST endpoints. Call them with `db.$queryRaw`:
+
+```ts
+const [row] = await db.$queryRaw<{ get_user_balance: number }>(
+  'SELECT get_user_balance($1)',
+  [userId],
+);
+
+const products = await db.$queryRaw<{ id: string; name: string; price: string }>(
+  'SELECT * FROM search_products($1)',
+  [query],
+);
+```
+
 ---
 
 ## Quick Start

package/dist/cli/templates/agents.md

@@ -14,7 +14,7 @@ schematic-pg is a single-file backend framework for PostgreSQL and Node.js. **`a
 
 1. **Never edit `generated/`** — it is overwritten on every `generate` / `dev` run.
 2. **Regenerate after changes** to `app.schema`, `src/routes/`, or `src/hooks/` (`schematic-pg generate` or `schematic-pg dev`).
-3. **Edit `app.schema`** for models, relations, policies, indexes, and triggers.
+3. **Edit `app.schema`** for models, relations, policies, indexes, triggers, and SQL functions.
 4. **Use extension points** for app-specific logic: `src/routes/` (custom HTTP) and `src/hooks/` (lifecycle hooks).
 5. **Do not hand-write SQL** for CRUD — use the generated DB client or REST API.
 
@@ -100,6 +100,7 @@ models {
 - **Policies:** `@policy(role: ..., allow: [select|insert|update|delete|all], where: "...")` — `where` supports `{{auth.user.id}}`.
 - **Validation:** `@regex(...)`, `@range(min: ..., max: ...)` flow into generated Zod schemas.
 - **Indexes / triggers:** `@@index(...)`, `@@trigger { timing, event, level, execute: """...""" }`.
+- **SQL functions:** optional `functions { function name(args): ReturnType { execute: """...""" } }` after `models`. `ReturnType` may be a scalar (`INTEGER`, `TRIGGER`, `VOID`, …) or `TABLE(col: Type, …)`. Names snake_case in SQL; call scalars with `SELECT fn($1)`, table functions with `SELECT * FROM fn($1)` via `db.$queryRaw`.
 
 ## Database Client
 

package/dist/schema-dsl/ast.d.ts

@@ -9,6 +9,7 @@ export interface Schema {
     extensions: Extension[];
     enums: Enum[];
     models: Model[];
+    functions: SqlFunction[];
     loc: SourceLocation;
 }
 export interface Extension {
@@ -31,6 +32,30 @@ export interface Model {
     directives: Directive[];
     loc: SourceLocation;
 }
+export interface SqlFunction {
+    kind: 'SqlFunction';
+    name: string;
+    params: FunctionParam[];
+    returns: FunctionReturn;
+    language?: string;
+    volatility?: string;
+    security?: string;
+    execute: string;
+    loc: SourceLocation;
+}
+export interface FunctionParam {
+    kind: 'FunctionParam';
+    name: string;
+    type: TypeExpr;
+    loc: SourceLocation;
+}
+export interface TableReturn {
+    kind: 'TableReturn';
+    columns: FunctionParam[];
+    loc: SourceLocation;
+}
+export type FunctionReturn = TypeExpr | TableReturn;
+export declare function isTableReturn(returns: FunctionReturn): returns is TableReturn;
 export interface Field {
     kind: 'Field';
     name: string;

package/dist/schema-dsl/ast.js

@@ -1 +1,3 @@
-export {};
+export function isTableReturn(returns) {
+    return returns.kind === 'TableReturn';
+}

package/dist/schema-dsl/lexer.js

@@ -130,7 +130,10 @@ export class Lexer {
     scanTripleString(startLine, startCol) {
         let value = '';
         while (!this.isAtEnd()) {
-            if (this.match('"') && this.match('"') && this.match('"')) {
+            if (this.peekChar() === '"' && this.peekChar(1) === '"' && this.peekChar(2) === '"') {
+                this.advance();
+                this.advance();
+                this.advance();
                 return this.makeToken(TokenType.TRIPLE_STRING, value, startLine, startCol);
             }
             value += this.advance();

package/dist/schema-dsl/parser.d.ts

@@ -1,4 +1,4 @@
-import type { Attribute, Field, Model, Schema } from './ast.js';
+import type { Attribute, Field, Model, Schema, SqlFunction } from './ast.js';
 import { Token } from './tokens.js';
 export declare class ParseError extends Error {
     readonly line: number;
@@ -20,6 +20,13 @@ export declare class Parser {
     private parseEnumsSection;
     private parseEnum;
     private parseModelsSection;
+    private parseFunctionsSection;
+    parseFunction(existingNames?: Set<string>): SqlFunction;
+    private parseFunctionReturn;
+    private parseTableReturn;
+    private parseFunctionParams;
+    private parseFunctionParam;
+    private parseFunctionBody;
     private parseModelBody;
     private parseTypeExpr;
     private parseFieldAttributes;

package/dist/schema-dsl/parser.js

@@ -24,12 +24,14 @@ export class Parser {
         const extensions = this.parseExtensionsSection();
         const enums = this.parseEnumsSection();
         const models = this.parseModelsSection();
+        const functions = this.check(TokenType.FUNCTIONS) ? this.parseFunctionsSection() : [];
         this.expect(TokenType.EOF, 'end of schema');
         return {
             kind: 'Schema',
             extensions,
             enums,
             models,
+            functions,
             loc: this.loc(start),
         };
     }
@@ -113,6 +115,182 @@ export class Parser {
         this.expect(TokenType.RBRACE, "'}'");
         return models;
     }
+    parseFunctionsSection() {
+        this.expect(TokenType.FUNCTIONS, "'functions'");
+        this.expect(TokenType.LBRACE, "'{'");
+        const functions = [];
+        const names = new Set();
+        while (!this.check(TokenType.RBRACE)) {
+            functions.push(this.parseFunction(names));
+        }
+        this.expect(TokenType.RBRACE, "'}'");
+        return functions;
+    }
+    parseFunction(existingNames) {
+        const start = this.expect(TokenType.FUNCTION, "'function'");
+        const nameToken = this.expect(TokenType.IDENT, 'function name');
+        if (existingNames?.has(nameToken.value)) {
+            throw new ParseError(`unique function name, "${nameToken.value}" already defined`, nameToken);
+        }
+        existingNames?.add(nameToken.value);
+        this.expect(TokenType.LPAREN, "'('");
+        const params = this.parseFunctionParams();
+        this.expect(TokenType.RPAREN, "')'");
+        this.expect(TokenType.COLON, "':'");
+        const returns = this.parseFunctionReturn(params);
+        this.expect(TokenType.LBRACE, "'{'");
+        const body = this.parseFunctionBody();
+        this.expect(TokenType.RBRACE, "'}'");
+        return {
+            kind: 'SqlFunction',
+            name: nameToken.value,
+            params,
+            returns,
+            language: body.language,
+            volatility: body.volatility,
+            security: body.security,
+            execute: body.execute,
+            loc: this.loc(start),
+        };
+    }
+    parseFunctionReturn(params) {
+        const current = this.current();
+        if (current.type === TokenType.IDENT &&
+            current.value === 'TABLE' &&
+            this.peekType(1) === TokenType.LPAREN) {
+            return this.parseTableReturn(params);
+        }
+        if (current.type === TokenType.IDENT && current.value === 'TABLE') {
+            throw new ParseError("TABLE column list '(...)'", current);
+        }
+        return this.parseTypeExpr();
+    }
+    parseTableReturn(params) {
+        const start = this.expect(TokenType.IDENT, "'TABLE'");
+        this.expect(TokenType.LPAREN, "'('");
+        if (this.check(TokenType.RPAREN)) {
+            throw new ParseError('at least one TABLE column', this.current());
+        }
+        const columns = [];
+        const columnNames = new Set();
+        const paramNames = new Set(params.map((param) => param.name));
+        do {
+            const nameToken = this.expect(TokenType.IDENT, 'TABLE column name');
+            if (columnNames.has(nameToken.value)) {
+                throw new ParseError(`unique TABLE column name, "${nameToken.value}" already defined`, nameToken);
+            }
+            if (paramNames.has(nameToken.value)) {
+                throw new ParseError(`TABLE column name distinct from parameter "${nameToken.value}"`, nameToken);
+            }
+            columnNames.add(nameToken.value);
+            this.expect(TokenType.COLON, "':'");
+            const type = this.parseTypeExpr();
+            columns.push({
+                kind: 'FunctionParam',
+                name: nameToken.value,
+                type,
+                loc: this.loc(nameToken),
+            });
+        } while (this.match(TokenType.COMMA) && !this.check(TokenType.RPAREN));
+        this.consumeTrailingComma();
+        this.expect(TokenType.RPAREN, "')'");
+        return {
+            kind: 'TableReturn',
+            columns,
+            loc: this.loc(start),
+        };
+    }
+    parseFunctionParams() {
+        if (this.check(TokenType.RPAREN)) {
+            return [];
+        }
+        const params = [];
+        do {
+            params.push(this.parseFunctionParam());
+        } while (this.match(TokenType.COMMA) && !this.check(TokenType.RPAREN));
+        this.consumeTrailingComma();
+        return params;
+    }
+    parseFunctionParam() {
+        const start = this.expect(TokenType.IDENT, 'parameter name');
+        this.expect(TokenType.COLON, "':'");
+        const type = this.parseTypeExpr();
+        return {
+            kind: 'FunctionParam',
+            name: start.value,
+            type,
+            loc: this.loc(start),
+        };
+    }
+    parseFunctionBody() {
+        if (this.check(TokenType.RBRACE)) {
+            throw new ParseError("function body key 'execute'", this.current());
+        }
+        let language;
+        let volatility;
+        let security;
+        let execute;
+        do {
+            const keyToken = this.expect(TokenType.IDENT, 'function body key');
+            this.expect(TokenType.COLON, "':'");
+            const valueToken = this.current();
+            const value = this.parseValue();
+            switch (keyToken.value) {
+                case 'language': {
+                    if (value.kind !== 'Identifier') {
+                        throw new ParseError("'sql' or 'plpgsql'", valueToken);
+                    }
+                    const languageName = value.name.toLowerCase();
+                    if (languageName !== 'sql' && languageName !== 'plpgsql') {
+                        throw new ParseError("'sql' or 'plpgsql'", valueToken);
+                    }
+                    language = languageName;
+                    break;
+                }
+                case 'volatility': {
+                    if (value.kind !== 'Identifier') {
+                        throw new ParseError("'VOLATILE', 'STABLE', or 'IMMUTABLE'", valueToken);
+                    }
+                    const volatilityName = value.name.toUpperCase();
+                    if (volatilityName !== 'VOLATILE' &&
+                        volatilityName !== 'STABLE' &&
+                        volatilityName !== 'IMMUTABLE') {
+                        throw new ParseError("'VOLATILE', 'STABLE', or 'IMMUTABLE'", valueToken);
+                    }
+                    volatility = volatilityName;
+                    break;
+                }
+                case 'security': {
+                    if (value.kind !== 'Identifier') {
+                        throw new ParseError("'INVOKER' or 'DEFINER'", valueToken);
+                    }
+                    const securityName = value.name.toUpperCase();
+                    if (securityName !== 'INVOKER' && securityName !== 'DEFINER') {
+                        throw new ParseError("'INVOKER' or 'DEFINER'", valueToken);
+                    }
+                    security = securityName;
+                    break;
+                }
+                case 'execute': {
+                    if (value.kind !== 'TripleStringLiteral') {
+                        throw new ParseError('triple-quoted execute body', valueToken);
+                    }
+                    execute = value.value.trim();
+                    if (execute.length === 0) {
+                        throw new ParseError('non-empty execute body', valueToken);
+                    }
+                    break;
+                }
+                default:
+                    throw new ParseError("function body key 'language', 'volatility', 'security', or 'execute'", keyToken);
+            }
+            this.match(TokenType.COMMA);
+        } while (!this.check(TokenType.RBRACE));
+        if (!execute) {
+            throw new ParseError("function body key 'execute'", this.current());
+        }
+        return { language, volatility, security, execute };
+    }
     parseModelBody(name, start) {
         const fields = [];
         const attributes = [];

package/dist/schema-dsl/tokens.d.ts

@@ -3,6 +3,8 @@ export declare enum TokenType {
     ENUMS = "ENUMS",
     MODELS = "MODELS",
     MODEL = "MODEL",
+    FUNCTIONS = "FUNCTIONS",
+    FUNCTION = "FUNCTION",
     STRING = "STRING",
     TRIPLE_STRING = "TRIPLE_STRING",
     NUMBER = "NUMBER",

package/dist/schema-dsl/tokens.js

@@ -4,6 +4,8 @@ export var TokenType;
     TokenType["ENUMS"] = "ENUMS";
     TokenType["MODELS"] = "MODELS";
     TokenType["MODEL"] = "MODEL";
+    TokenType["FUNCTIONS"] = "FUNCTIONS";
+    TokenType["FUNCTION"] = "FUNCTION";
     TokenType["STRING"] = "STRING";
     TokenType["TRIPLE_STRING"] = "TRIPLE_STRING";
     TokenType["NUMBER"] = "NUMBER";
@@ -27,6 +29,8 @@ const KEYWORDS = {
     enums: TokenType.ENUMS,
     models: TokenType.MODELS,
     model: TokenType.MODEL,
+    functions: TokenType.FUNCTIONS,
+    function: TokenType.FUNCTION,
     true: TokenType.BOOLEAN,
     false: TokenType.BOOLEAN,
 };

package/dist/sql-generator/generators/functions.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from '../../schema-dsl/ast.js';
+import { type NormalizedFunction } from '../utils/ast-helpers.js';
+export type { NormalizedFunction };
+export declare function generateCreateFunction(normalized: NormalizedFunction): string;
+export declare function generateDropFunction(normalized: NormalizedFunction): string;
+export declare function generateFunctions(schema: Schema): string;

package/dist/sql-generator/generators/functions.js

@@ -0,0 +1,50 @@
+import { formatNormalizedFunctionReturn, getEnumNames, normalizeFunction, } from '../utils/ast-helpers.js';
+import { joinSection } from '../utils/format.js';
+import { quoteIdentifier } from '../utils/snake-case.js';
+export function generateCreateFunction(normalized) {
+    const functionName = quoteIdentifier(normalized.sqlName);
+    const params = normalized.params
+        .map((param) => `${quoteIdentifier(param.sqlName)} ${param.sqlType}`)
+        .join(', ');
+    const clauses = [
+        `CREATE OR REPLACE FUNCTION ${functionName}(${params})`,
+        `RETURNS ${formatNormalizedFunctionReturn(normalized.returns)}`,
+        `LANGUAGE ${normalized.language}`,
+    ];
+    if (normalized.volatility !== 'VOLATILE') {
+        clauses.push(normalized.volatility);
+    }
+    if (normalized.security === 'DEFINER') {
+        clauses.push('SECURITY DEFINER');
+    }
+    const body = formatFunctionBody(normalized.execute, normalized.language);
+    clauses.push(`AS $$\n${body}\n$$;`);
+    return clauses.join('\n');
+}
+export function generateDropFunction(normalized) {
+    const functionName = quoteIdentifier(normalized.sqlName);
+    const argTypes = normalized.params.map((param) => param.sqlType).join(', ');
+    return `DROP FUNCTION IF EXISTS ${functionName}(${argTypes});`;
+}
+export function generateFunctions(schema) {
+    const enumNames = getEnumNames(schema);
+    const statements = schema.functions.map((sqlFunction) => generateCreateFunction(normalizeFunction(sqlFunction, enumNames)));
+    return joinSection('Create functions', statements);
+}
+function formatFunctionBody(execute, language) {
+    const trimmed = execute.trim();
+    const indented = indentBody(trimmed);
+    if (language !== 'plpgsql') {
+        return indented;
+    }
+    if (/^(declare|begin)\b/i.test(trimmed)) {
+        return indented;
+    }
+    return `BEGIN\n${indented}\nEND;`;
+}
+function indentBody(body) {
+    return body
+        .split('\n')
+        .map((line) => (line.length > 0 ? `  ${line}` : line))
+        .join('\n');
+}

package/dist/sql-generator/migration-planner.d.ts

@@ -9,6 +9,7 @@ export declare class MigrationPlanner {
     private diffConstraints;
     private diffIndexes;
     private diffTriggers;
+    private diffFunctions;
     private triggerSignatures;
     private indexSignatures;
 }

package/dist/sql-generator/migration-planner.js

@@ -1,4 +1,4 @@
-import { collectForeignKeys, getDirectives, getEnumNames, getModelNames, getStoredFields, isStoredField, normalizeIndexDirective, normalizeTriggerDirective, serializeColumnType, serializeDefault, serializeForeignKey, } from './utils/ast-helpers.js';
+import { collectForeignKeys, functionIdentity, functionSignature, getDirectives, getEnumNames, getModelNames, getStoredFields, isStoredField, normalizeFunction, normalizeIndexDirective, normalizeTriggerDirective, serializeColumnType, serializeDefault, serializeForeignKey, } from './utils/ast-helpers.js';
 export class MigrationPlanner {
     generateMigration(oldSchema, newSchema) {
         const migrations = [];
@@ -7,6 +7,7 @@ export class MigrationPlanner {
         migrations.push(...this.diffModels(oldSchema, newSchema));
         migrations.push(...this.diffConstraints(oldSchema, newSchema));
         migrations.push(...this.diffIndexes(oldSchema, newSchema));
+        migrations.push(...this.diffFunctions(oldSchema, newSchema));
         migrations.push(...this.diffTriggers(oldSchema, newSchema));
         return migrations;
     }
@@ -195,6 +196,48 @@ export class MigrationPlanner {
         }
         return migrations;
     }
+    diffFunctions(oldSchema, newSchema) {
+        const migrations = [];
+        const oldEnumNames = getEnumNames(oldSchema);
+        const newEnumNames = getEnumNames(newSchema);
+        const oldFunctions = new Map(oldSchema.functions.map((sqlFunction) => [
+            sqlFunction.name,
+            normalizeFunction(sqlFunction, oldEnumNames),
+        ]));
+        const newFunctions = new Map(newSchema.functions.map((sqlFunction) => [
+            sqlFunction.name,
+            normalizeFunction(sqlFunction, newEnumNames),
+        ]));
+        for (const [functionName, newFunction] of newFunctions) {
+            const oldFunction = oldFunctions.get(functionName);
+            if (!oldFunction) {
+                migrations.push({ kind: 'CreateFunction', functionName });
+                continue;
+            }
+            if (functionIdentity(oldFunction) !== functionIdentity(newFunction)) {
+                migrations.push({
+                    kind: 'DropFunction',
+                    functionName,
+                    signature: functionSignature(oldFunction),
+                });
+                migrations.push({ kind: 'CreateFunction', functionName });
+                continue;
+            }
+            if (functionSignature(oldFunction) !== functionSignature(newFunction)) {
+                migrations.push({ kind: 'ReplaceFunction', functionName });
+            }
+        }
+        for (const [functionName, oldFunction] of oldFunctions) {
+            if (!newFunctions.has(functionName)) {
+                migrations.push({
+                    kind: 'DropFunction',
+                    functionName,
+                    signature: functionSignature(oldFunction),
+                });
+            }
+        }
+        return migrations;
+    }
     triggerSignatures(model) {
         return new Set(getDirectives(model, 'trigger').map((directive) => JSON.stringify(normalizeTriggerDirective(directive))));
     }

package/dist/sql-generator/migration-sql-generator.js

@@ -1,10 +1,11 @@
 import { generateAddEnumValue, generateEnum } from './generators/enums.js';
 import { generateCreateExtension, generateDropExtension } from './generators/extensions.js';
 import { generateForeignKey } from './generators/foreign-keys.js';
+import { generateCreateFunction, generateDropFunction, } from './generators/functions.js';
 import { generateCreateIndex, generateDropIndex, } from './generators/indexes.js';
 import { generateColumnDefinition, generateTable } from './generators/tables.js';
 import { generateCreateTrigger, generateDropTrigger, } from './generators/triggers.js';
-import { getDirectives, getDefaultExpression, getEnumNames, getModelNames, getStoredFields, normalizeIndexDirective, normalizeTriggerDirective, parseForeignKeySignature, } from './utils/ast-helpers.js';
+import { getDirectives, getDefaultExpression, getEnumNames, getModelNames, getStoredFields, normalizeFunction, normalizeIndexDirective, normalizeTriggerDirective, parseForeignKeySignature, } from './utils/ast-helpers.js';
 import { quoteIdentifier, toSnakeCase, toTableName } from './utils/snake-case.js';
 const MIGRATION_ORDER = {
     CreateExtension: 0,
@@ -18,10 +19,13 @@ const MIGRATION_ORDER = {
     DropConstraint: 8,
     DropIndex: 9,
     CreateIndex: 10,
-    CreateTrigger: 11,
-    DropTrigger: 12,
-    DropTable: 13,
-    DropExtension: 14,
+    DropFunction: 11,
+    CreateFunction: 12,
+    ReplaceFunction: 13,
+    CreateTrigger: 14,
+    DropTrigger: 15,
+    DropTable: 16,
+    DropExtension: 17,
 };
 export class MigrationSqlGenerator {
     generate(migrations, newSchema) {
@@ -32,12 +36,20 @@ export class MigrationSqlGenerator {
         const modelNames = getModelNames(newSchema);
         const modelMap = new Map(newSchema.models.map((model) => [model.name, model]));
         const enumMap = new Map(newSchema.enums.map((enumDef) => [enumDef.name, enumDef]));
+        const functionMap = new Map(newSchema.functions.map((sqlFunction) => [sqlFunction.name, sqlFunction]));
         const ordered = [...migrations].sort((left, right) => MIGRATION_ORDER[left.kind] - MIGRATION_ORDER[right.kind]);
-        const statements = ordered.map((migration) => this.migrationToSql(migration, { newSchema, enumNames, modelNames, modelMap, enumMap }));
+        const statements = ordered.map((migration) => this.migrationToSql(migration, {
+            newSchema,
+            enumNames,
+            modelNames,
+            modelMap,
+            enumMap,
+            functionMap,
+        }));
         return `${statements.join('\n\n')}\n`;
     }
     migrationToSql(migration, context) {
-        const { enumNames, modelNames, modelMap, enumMap } = context;
+        const { enumNames, modelNames, modelMap, enumMap, functionMap } = context;
         switch (migration.kind) {
             case 'CreateExtension':
                 return generateCreateExtension(migration.extensionName);
@@ -147,6 +159,18 @@ export class MigrationSqlGenerator {
                 const normalized = JSON.parse(migration.signature);
                 return generateDropTrigger(model, normalized);
             }
+            case 'CreateFunction':
+            case 'ReplaceFunction': {
+                const sqlFunction = functionMap.get(migration.functionName);
+                if (!sqlFunction) {
+                    throw new Error(`Function "${migration.functionName}" not found in new schema`);
+                }
+                return generateCreateFunction(normalizeFunction(sqlFunction, enumNames));
+            }
+            case 'DropFunction': {
+                const normalized = JSON.parse(migration.signature);
+                return generateDropFunction(normalized);
+            }
             default: {
                 const exhaustive = migration;
                 throw new Error(`Unsupported migration kind: ${exhaustive.kind}`);

package/dist/sql-generator/migration-types.d.ts

@@ -1,4 +1,4 @@
-export type Migration = CreateExtension | DropExtension | CreateTable | DropTable | AddColumn | DropColumn | AlterColumn | CreateIndex | DropIndex | CreateEnum | AddEnumValue | AddConstraint | DropConstraint | CreateTrigger | DropTrigger;
+export type Migration = CreateExtension | DropExtension | CreateTable | DropTable | AddColumn | DropColumn | AlterColumn | CreateIndex | DropIndex | CreateEnum | AddEnumValue | AddConstraint | DropConstraint | CreateFunction | ReplaceFunction | DropFunction | CreateTrigger | DropTrigger;
 export interface CreateTable {
     kind: 'CreateTable';
     modelName: string;
@@ -84,3 +84,16 @@ export interface DropTrigger {
     modelName: string;
     signature: string;
 }
+export interface CreateFunction {
+    kind: 'CreateFunction';
+    functionName: string;
+}
+export interface ReplaceFunction {
+    kind: 'ReplaceFunction';
+    functionName: string;
+}
+export interface DropFunction {
+    kind: 'DropFunction';
+    functionName: string;
+    signature: string;
+}

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

@@ -3,6 +3,7 @@ import { generateDropTables } from './generators/drop-tables.js';
 import { generateEnums } from './generators/enums.js';
 import { generateExtensions } from './generators/extensions.js';
 import { generateForeignKeys } from './generators/foreign-keys.js';
+import { generateFunctions } from './generators/functions.js';
 import { generateIndexes } from './generators/indexes.js';
 import { generateTables } from './generators/tables.js';
 import { generateTriggers } from './generators/triggers.js';
@@ -15,6 +16,7 @@ export class SqlGenerator {
             generateTables(schema),
             generateForeignKeys(schema),
             generateIndexes(schema),
+            generateFunctions(schema),
             generateTriggers(schema),
         ];
         return `${sections.join('\n')}\n`;

package/dist/sql-generator/utils/ast-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Attribute, AttributeArgs, Directive, Field, KeyValueArgs, Model, Schema, TypeExpr, Value } from '../../schema-dsl/ast.js';
+import type { Attribute, AttributeArgs, Directive, Field, KeyValueArgs, Model, Schema, SqlFunction, TypeExpr, Value } from '../../schema-dsl/ast.js';
 export interface PrimaryKeyInfo {
     fields: string[];
     composite: boolean;
@@ -56,3 +56,29 @@ export interface TriggerNames {
 }
 export declare function normalizeTriggerDirective(directive: Directive): NormalizedTrigger;
 export declare function resolveTriggerNames(model: Model, timing: string, event: string): TriggerNames;
+export interface NormalizedFunctionParam {
+    name: string;
+    sqlName: string;
+    sqlType: string;
+}
+export type NormalizedFunctionReturn = {
+    kind: 'scalar';
+    sqlType: string;
+} | {
+    kind: 'table';
+    columns: NormalizedFunctionParam[];
+};
+export interface NormalizedFunction {
+    name: string;
+    sqlName: string;
+    params: NormalizedFunctionParam[];
+    returns: NormalizedFunctionReturn;
+    language: string;
+    volatility: string;
+    security: string;
+    execute: string;
+}
+export declare function normalizeFunction(sqlFunction: SqlFunction, enumNames: Set<string>): NormalizedFunction;
+export declare function formatNormalizedFunctionReturn(returns: NormalizedFunctionReturn): string;
+export declare function functionIdentity(normalized: NormalizedFunction): string;
+export declare function functionSignature(normalized: NormalizedFunction): string;

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

@@ -1,6 +1,7 @@
+import { isTableReturn } from '../../schema-dsl/ast.js';
 import { formatDefaultValue, serializeValue } from './value-formatter.js';
 import { mapColumnType } from './type-mapper.js';
-import { toSnakeCase, toTableName } from './snake-case.js';
+import { toSnakeCase, toTableName, quoteIdentifier } from './snake-case.js';
 export function getModelNames(schema) {
     return new Set(schema.models.map((model) => model.name));
 }
@@ -250,3 +251,52 @@ export function resolveTriggerNames(model, timing, event) {
         triggerName: `${baseName}_trigger`,
     };
 }
+export function normalizeFunction(sqlFunction, enumNames) {
+    const params = sqlFunction.params.map((param) => ({
+        name: param.name,
+        sqlName: toSnakeCase(param.name),
+        sqlType: serializeColumnType(param.type, enumNames),
+    }));
+    const returns = isTableReturn(sqlFunction.returns)
+        ? {
+            kind: 'table',
+            columns: sqlFunction.returns.columns.map((column) => ({
+                name: column.name,
+                sqlName: toSnakeCase(column.name),
+                sqlType: serializeColumnType(column.type, enumNames),
+            })),
+        }
+        : {
+            kind: 'scalar',
+            sqlType: serializeColumnType(sqlFunction.returns, enumNames),
+        };
+    return {
+        name: sqlFunction.name,
+        sqlName: toSnakeCase(sqlFunction.name),
+        params,
+        returns,
+        language: (sqlFunction.language ?? 'sql').toLowerCase(),
+        volatility: (sqlFunction.volatility ?? 'VOLATILE').toUpperCase(),
+        security: (sqlFunction.security ?? 'INVOKER').toUpperCase(),
+        execute: sqlFunction.execute.trim(),
+    };
+}
+export function formatNormalizedFunctionReturn(returns) {
+    if (returns.kind === 'scalar') {
+        return returns.sqlType;
+    }
+    const columns = returns.columns
+        .map((column) => `${quoteIdentifier(column.sqlName)} ${column.sqlType}`)
+        .join(', ');
+    return `TABLE (${columns})`;
+}
+export function functionIdentity(normalized) {
+    return JSON.stringify({
+        sqlName: normalized.sqlName,
+        params: normalized.params.map((param) => param.sqlType),
+        returns: normalized.returns,
+    });
+}
+export function functionSignature(normalized) {
+    return JSON.stringify(normalized);
+}

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

@@ -13,6 +13,9 @@ const PRIMITIVE_TYPES = new Set([
     'TIMESTAMP',
 ]);
 export function mapColumnType(type, enumNames) {
+    if (type.name === 'TRIGGER' || type.name === 'VOID') {
+        return type.name;
+    }
     const baseType = mapBaseType(type, enumNames);
     return type.array ? `${baseType}[]` : baseType;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schematic-pg",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Single-file backend framework for PostgreSQL and Node.js",
   "type": "module",
   "license": "MIT",