relq 1.0.31 → 1.0.33

package/dist/cjs/cli/commands/add.cjs

@@ -113,7 +113,7 @@ function parseSchemaFileForComparison(schemaPath) {
                     continue;
                 const tsName = colMatch[1];
                 const type = colMatch[2];
-                const explicitNameMatch = colDef.match(new RegExp(`${type}\\s*\\(['\"]([^'"]+)['\"]`));
+                const explicitNameMatch = colDef.match(new RegExp(`${type}(?:<[^>]+>)?\\s*\\(['\"]([^'"]+)['\"]`));
                 const dbColName = explicitNameMatch ? explicitNameMatch[1] : tsName;
                 tsToDbNameMap.set(tsName, dbColName);
                 let defaultValue = null;
@@ -493,6 +493,12 @@ function parseSchemaFileForComparison(schemaPath) {
             }
         }
     }
+    const schemaDir = path.dirname(schemaPath);
+    const schemaBaseName = path.basename(schemaPath, '.ts');
+    const functionsPath = path.join(schemaDir, `${schemaBaseName}.functions.ts`);
+    const triggersPath = path.join(schemaDir, `${schemaBaseName}.triggers.ts`);
+    const functions = parseFunctionsFile(functionsPath);
+    const triggers = parseTriggersFile(triggersPath);
     return {
         tables,
         enums,
@@ -500,8 +506,8 @@ function parseSchemaFileForComparison(schemaPath) {
         compositeTypes: [],
         sequences: [],
         collations: [],
-        functions: [],
-        triggers: [],
+        functions,
+        triggers,
         policies: [],
         partitions: [],
         foreignServers: [],
@@ -509,6 +515,132 @@ function parseSchemaFileForComparison(schemaPath) {
         extensions,
     };
 }
+function parseFunctionsFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const rawContent = fs.readFileSync(filePath, 'utf-8');
+    const content = (0, strip_comments_1.default)(rawContent);
+    const functions = [];
+    const funcPattern = /pgFunction\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{/g;
+    let funcMatch;
+    while ((funcMatch = funcPattern.exec(content)) !== null) {
+        const funcName = funcMatch[1];
+        const startIdx = funcMatch.index + funcMatch[0].length;
+        let braceCount = 1;
+        let endIdx = startIdx;
+        while (braceCount > 0 && endIdx < content.length) {
+            const char = content[endIdx];
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+            endIdx++;
+        }
+        const optionsBlock = content.substring(startIdx, endIdx - 1);
+        const returnsMatch = optionsBlock.match(/returns:\s*['"]([^'"]+)['"]/);
+        const returnType = returnsMatch ? returnsMatch[1] : 'void';
+        const languageMatch = optionsBlock.match(/language:\s*['"]([^'"]+)['"]/);
+        const language = languageMatch ? languageMatch[1] : 'plpgsql';
+        const volatilityMatch = optionsBlock.match(/volatility:\s*['"]([^'"]+)['"]/);
+        const volatility = volatilityMatch ? volatilityMatch[1] : 'VOLATILE';
+        const argsMatch = optionsBlock.match(/args:\s*\[([^\]]*)\]/s);
+        const argTypes = [];
+        if (argsMatch) {
+            const argsBlock = argsMatch[1];
+            const typeMatches = argsBlock.matchAll(/type:\s*['"]([^'"]+)['"]/g);
+            for (const m of typeMatches) {
+                argTypes.push(m[1]);
+            }
+        }
+        const bodyMatch = optionsBlock.match(/body:\s*`([^`]*)`/s) || optionsBlock.match(/raw:\s*`([^`]*)`/s);
+        const definition = bodyMatch ? bodyMatch[1].trim() : '';
+        functions.push({
+            name: funcName,
+            schema: 'public',
+            returnType,
+            argTypes,
+            language,
+            definition,
+            isAggregate: false,
+            volatility,
+        });
+    }
+    return functions;
+}
+function parseTriggersFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const rawContent = fs.readFileSync(filePath, 'utf-8');
+    const content = (0, strip_comments_1.default)(rawContent);
+    const triggers = [];
+    const trigPattern = /pgTrigger\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{/g;
+    let trigMatch;
+    while ((trigMatch = trigPattern.exec(content)) !== null) {
+        const trigName = trigMatch[1];
+        const startIdx = trigMatch.index + trigMatch[0].length;
+        let braceCount = 1;
+        let endIdx = startIdx;
+        while (braceCount > 0 && endIdx < content.length) {
+            const char = content[endIdx];
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+            endIdx++;
+        }
+        const optionsBlock = content.substring(startIdx, endIdx - 1);
+        let tableName = '';
+        const onSchemaMatch = optionsBlock.match(/on:\s*schema\.(\w+)/);
+        const onStringMatch = optionsBlock.match(/on:\s*['"]([^'"]+)['"]/);
+        if (onSchemaMatch) {
+            tableName = onSchemaMatch[1].replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+        }
+        else if (onStringMatch) {
+            tableName = onStringMatch[1];
+        }
+        let timing = 'BEFORE';
+        let event = 'UPDATE';
+        const beforeMatch = optionsBlock.match(/before:\s*['"]?(\w+)['"]?/);
+        const afterMatch = optionsBlock.match(/after:\s*['"]?(\w+)['"]?/);
+        const insteadOfMatch = optionsBlock.match(/insteadOf:\s*['"]?(\w+)['"]?/);
+        if (beforeMatch) {
+            timing = 'BEFORE';
+            event = beforeMatch[1].toUpperCase();
+        }
+        else if (afterMatch) {
+            timing = 'AFTER';
+            event = afterMatch[1].toUpperCase();
+        }
+        else if (insteadOfMatch) {
+            timing = 'INSTEAD OF';
+            event = insteadOfMatch[1].toUpperCase();
+        }
+        const forEachMatch = optionsBlock.match(/forEach:\s*['"]?(\w+)['"]?/);
+        const forEach = forEachMatch && forEachMatch[1].toUpperCase() === 'STATEMENT' ? 'STATEMENT' : 'ROW';
+        let functionName = '';
+        const execFuncMatch = optionsBlock.match(/execute:\s*functions\.(\w+)/);
+        const execStringMatch = optionsBlock.match(/execute:\s*['"]([^'"]+)['"]/);
+        if (execFuncMatch) {
+            functionName = execFuncMatch[1].replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+        }
+        else if (execStringMatch) {
+            functionName = execStringMatch[1];
+        }
+        triggers.push({
+            name: trigName,
+            tableName,
+            event,
+            timing,
+            forEach,
+            functionName,
+            definition: '',
+            isEnabled: true,
+        });
+    }
+    return triggers;
+}
 function snapshotToDatabaseSchema(snapshot) {
     const tables = (snapshot.tables || []).map(t => ({
         name: t.name,
@@ -549,6 +681,26 @@ function snapshotToDatabaseSchema(snapshot) {
         partitionType: t.partitionType,
         partitionKey: t.partitionKey ? (Array.isArray(t.partitionKey) ? t.partitionKey : [t.partitionKey]) : undefined,
     }));
+    const functions = (snapshot.functions || []).map(f => ({
+        name: f.name,
+        schema: f.schema || 'public',
+        returnType: f.returnType,
+        argTypes: f.argTypes || [],
+        language: f.language,
+        definition: f.body || '',
+        isAggregate: false,
+        volatility: f.volatility || 'VOLATILE',
+    }));
+    const triggers = (snapshot.triggers || []).map(t => ({
+        name: t.name,
+        tableName: t.table,
+        event: t.events?.[0] || 'UPDATE',
+        timing: t.timing,
+        forEach: t.forEach || 'ROW',
+        functionName: t.functionName,
+        definition: '',
+        isEnabled: true,
+    }));
     return {
         tables,
         enums: (snapshot.enums || []).map(e => ({ name: e.name, values: e.values })),
@@ -556,8 +708,8 @@ function snapshotToDatabaseSchema(snapshot) {
         compositeTypes: [],
         sequences: [],
         collations: [],
-        functions: [],
-        triggers: [],
+        functions,
+        triggers,
         policies: [],
         partitions: [],
         foreignServers: [],

package/dist/cjs/cli/commands/pull.cjs

@@ -40,6 +40,7 @@ const config_loader_1 = require("../utils/config-loader.cjs");
 const fast_introspect_1 = require("../utils/fast-introspect.cjs");
 const ast_transformer_1 = require("../utils/ast-transformer.cjs");
 const ast_codegen_1 = require("../utils/ast-codegen.cjs");
+const types_manager_1 = require("../utils/types-manager.cjs");
 const env_loader_1 = require("../utils/env-loader.cjs");
 const cli_utils_1 = require("../utils/cli-utils.cjs");
 const relqignore_1 = require("../utils/relqignore.cjs");
@@ -545,7 +546,18 @@ async function pullCommand(context) {
                 (0, cli_utils_1.fatal)('Automatic merge failed; fix conflicts and then commit', `${cli_utils_1.colors.cyan('relq resolve --theirs <name>')}  Take remote version\n${cli_utils_1.colors.cyan('relq resolve --all-theirs')}     Take all remote\n${cli_utils_1.colors.cyan('relq pull --force')}             Force overwrite local`);
             }
             if (allChanges.length === 0) {
-                console.log('Already up to date with remote');
+                const localCommits = (0, repo_manager_1.getAllCommits)(projectRoot);
+                const localHashes = new Set(localCommits.map(c => c.hash));
+                const missingCommits = remoteCommits.filter(c => !localHashes.has(c.hash));
+                if (missingCommits.length > 0) {
+                    for (const commit of missingCommits.reverse()) {
+                        (0, repo_manager_1.saveCommit)(commit, projectRoot);
+                    }
+                    console.log(`Synced ${missingCommits.length} commit(s) from remote`);
+                }
+                else {
+                    console.log('Already up to date with remote');
+                }
                 console.log('');
                 return;
             }
@@ -708,6 +720,17 @@ async function pullCommand(context) {
                 spinner.succeed(`Written ${cli_utils_1.colors.cyan(triggersPath)} ${cli_utils_1.colors.muted(`(${(0, cli_utils_1.formatBytes)(trigFileSize)})`)}`);
             }
         }
+        const typesFilePath = (0, types_manager_1.getTypesFilePath)(schemaPath);
+        const typesResult = await (0, types_manager_1.syncTypesFromDb)(connection, typesFilePath);
+        if (typesResult.generated) {
+            const typesFileSize = fs.existsSync(typesFilePath) ? fs.statSync(typesFilePath).size : 0;
+            if (typesResult.typesCount > 0) {
+                spinner.succeed(`Written ${cli_utils_1.colors.cyan(typesFilePath)} ${cli_utils_1.colors.muted(`(${typesResult.typesCount} types, ${(0, cli_utils_1.formatBytes)(typesFileSize)})`)}`);
+            }
+            else {
+                spinner.succeed(`Created ${cli_utils_1.colors.cyan(typesFilePath)} ${cli_utils_1.colors.muted('(empty template)')}`);
+            }
+        }
         const oldSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
         const beforeSchema = oldSnapshot ? {
             extensions: oldSnapshot.extensions?.map(e => e.name) || [],

package/dist/cjs/cli/commands/push.cjs

@@ -42,6 +42,8 @@ const cli_utils_1 = require("../utils/cli-utils.cjs");
 const fast_introspect_1 = require("../utils/fast-introspect.cjs");
 const relqignore_1 = require("../utils/relqignore.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
+const types_manager_1 = require("../utils/types-manager.cjs");
+const config_loader_2 = require("../utils/config-loader.cjs");
 async function pushCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -146,8 +148,32 @@ async function pushCommand(context) {
                 }
             }
         }
+        const schemaPath = (0, config_loader_2.getSchemaPath)(config);
+        const typesFilePath = (0, types_manager_1.getTypesFilePath)(schemaPath);
+        let typesSynced = false;
+        if (fs.existsSync(typesFilePath) && !dryRun) {
+            spinner.start('Syncing TypeScript types...');
+            const typesResult = await (0, types_manager_1.syncTypesToDb)(connection, typesFilePath, schemaPath);
+            const totalChanges = typesResult.added.length + typesResult.updated.length + typesResult.removed.length;
+            if (totalChanges > 0) {
+                const parts = [];
+                if (typesResult.added.length > 0)
+                    parts.push(`${typesResult.added.length} added`);
+                if (typesResult.updated.length > 0)
+                    parts.push(`${typesResult.updated.length} updated`);
+                if (typesResult.removed.length > 0)
+                    parts.push(`${typesResult.removed.length} removed`);
+                spinner.succeed(`Synced types: ${parts.join(', ')}`);
+                typesSynced = true;
+            }
+            else {
+                spinner.succeed('Types in sync');
+            }
+        }
         if (toPush.length === 0 && !hasObjectsToDrop) {
-            console.log('Everything up-to-date');
+            if (!typesSynced) {
+                console.log('Everything up-to-date');
+            }
             console.log('');
             return;
         }

package/dist/cjs/cli/utils/types-manager.cjs

@@ -0,0 +1,413 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTypesTable = ensureTypesTable;
+exports.typesTableExists = typesTableExists;
+exports.parseTypesFile = parseTypesFile;
+exports.extractUsedTypes = extractUsedTypes;
+exports.extractTypeUsages = extractTypeUsages;
+exports.getTypesFromDb = getTypesFromDb;
+exports.storeTypesInDb = storeTypesInDb;
+exports.removeStaleTypes = removeStaleTypes;
+exports.generateTypesFile = generateTypesFile;
+exports.validateTypesUsage = validateTypesUsage;
+exports.isValidTypesFilePath = isValidTypesFilePath;
+exports.getTypesFilePath = getTypesFilePath;
+exports.syncTypesToDb = syncTypesToDb;
+exports.syncTypesFromDb = syncTypesFromDb;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _relq_types (
+    name TEXT PRIMARY KEY,
+    kind TEXT NOT NULL CHECK (kind IN ('interface', 'type')),
+    source TEXT NOT NULL,
+    usages JSONB DEFAULT '[]',
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_relq_types_kind ON _relq_types(kind);
+`;
+const ADD_USAGES_COLUMN_SQL = `
+ALTER TABLE _relq_types ADD COLUMN IF NOT EXISTS usages JSONB DEFAULT '[]';
+`;
+async function createPool(connection) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
+    return new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+}
+async function ensureTypesTable(connection) {
+    const pool = await createPool(connection);
+    try {
+        await pool.query(CREATE_TABLE_SQL);
+        await pool.query(ADD_USAGES_COLUMN_SQL);
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function typesTableExists(connection) {
+    const pool = await createPool(connection);
+    try {
+        const result = await pool.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_name = '_relq_types'
+            ) as exists
+        `);
+        return result.rows[0]?.exists ?? false;
+    }
+    finally {
+        await pool.end();
+    }
+}
+function parseTypesFile(content) {
+    const definitions = [];
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const interfaceMatch = line.match(/^(?:export\s+)?interface\s+(\w+)(?:<[^>]+>)?\s*\{?\s*$/);
+        if (interfaceMatch) {
+            const name = interfaceMatch[1];
+            const startLine = i;
+            const { endLine, source } = extractBlock(lines, i);
+            definitions.push({ name, kind: 'interface', source, startLine, endLine });
+            i = endLine + 1;
+            continue;
+        }
+        const interfaceExtendsMatch = line.match(/^(?:export\s+)?interface\s+(\w+)(?:<[^>]+>)?\s+extends\s+/);
+        if (interfaceExtendsMatch) {
+            const name = interfaceExtendsMatch[1];
+            const startLine = i;
+            const { endLine, source } = extractBlock(lines, i);
+            definitions.push({ name, kind: 'interface', source, startLine, endLine });
+            i = endLine + 1;
+            continue;
+        }
+        const typeMatch = line.match(/^(?:export\s+)?type\s+(\w+)(?:<[^>]+>)?\s*=\s*/);
+        if (typeMatch) {
+            const name = typeMatch[1];
+            const startLine = i;
+            const { endLine, source } = extractTypeAlias(lines, i);
+            definitions.push({ name, kind: 'type', source, startLine, endLine });
+            i = endLine + 1;
+            continue;
+        }
+        i++;
+    }
+    return definitions;
+}
+function extractBlock(lines, startIdx) {
+    let depth = 0;
+    let started = false;
+    let endIdx = startIdx;
+    for (let i = startIdx; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+            if (char === '{') {
+                depth++;
+                started = true;
+            }
+            else if (char === '}') {
+                depth--;
+            }
+        }
+        if (started && depth === 0) {
+            endIdx = i;
+            break;
+        }
+    }
+    const source = lines.slice(startIdx, endIdx + 1).join('\n');
+    return { endLine: endIdx, source };
+}
+function extractTypeAlias(lines, startIdx) {
+    const firstLine = lines[startIdx];
+    if (firstLine.includes(';') && !firstLine.includes('{')) {
+        return { endLine: startIdx, source: firstLine };
+    }
+    let depth = 0;
+    let endIdx = startIdx;
+    for (let i = startIdx; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+            if (char === '{' || char === '(' || char === '<') {
+                depth++;
+            }
+            else if (char === '}' || char === ')' || char === '>') {
+                depth--;
+            }
+        }
+        if (line.includes(';') && depth === 0) {
+            endIdx = i;
+            break;
+        }
+        if (i > startIdx && depth === 0) {
+            const trimmed = line.trim();
+            if (trimmed === '' || trimmed.startsWith('export ')) {
+                endIdx = i - 1;
+                break;
+            }
+        }
+    }
+    const source = lines.slice(startIdx, endIdx + 1).join('\n');
+    return { endLine: endIdx, source };
+}
+function extractUsedTypes(schemaContent) {
+    const usedTypes = new Set();
+    const genericPattern = /(?:jsonb|json|varchar|text|char)\s*<\s*([A-Z][a-zA-Z0-9_]*)/g;
+    let match;
+    while ((match = genericPattern.exec(schemaContent)) !== null) {
+        usedTypes.add(match[1]);
+    }
+    return Array.from(usedTypes);
+}
+function extractTypeUsages(schemaContent) {
+    const usages = {};
+    const tablePattern = /(?:(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*)?defineTable\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{/g;
+    let tableMatch;
+    while ((tableMatch = tablePattern.exec(schemaContent)) !== null) {
+        const varName = tableMatch[1];
+        const tableName = tableMatch[2];
+        const tableStartIdx = tableMatch.index + tableMatch[0].length;
+        let depth = 1;
+        let columnsEndIdx = tableStartIdx;
+        for (let i = tableStartIdx; i < schemaContent.length && depth > 0; i++) {
+            if (schemaContent[i] === '{')
+                depth++;
+            else if (schemaContent[i] === '}')
+                depth--;
+            columnsEndIdx = i;
+        }
+        const columnsBlock = schemaContent.substring(tableStartIdx, columnsEndIdx);
+        const columnPattern = /(\w+)\s*:\s*(?:jsonb|json|varchar|text|char)\s*<\s*([A-Z][a-zA-Z0-9_]*)/g;
+        let columnMatch;
+        while ((columnMatch = columnPattern.exec(columnsBlock)) !== null) {
+            const columnName = columnMatch[1];
+            const typeName = columnMatch[2];
+            const tableRef = varName || tableName;
+            const usage = `${tableRef}.${columnName}`;
+            if (!usages[typeName]) {
+                usages[typeName] = [];
+            }
+            if (!usages[typeName].includes(usage)) {
+                usages[typeName].push(usage);
+            }
+        }
+    }
+    return usages;
+}
+async function getTypesFromDb(connection) {
+    const exists = await typesTableExists(connection);
+    if (!exists)
+        return [];
+    const pool = await createPool(connection);
+    try {
+        const result = await pool.query(`
+            SELECT name, kind, source, usages, created_at, updated_at
+            FROM _relq_types
+            ORDER BY name
+        `);
+        return result.rows.map(row => ({
+            name: row.name,
+            kind: row.kind,
+            source: row.source,
+            usages: row.usages || [],
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function storeTypesInDb(connection, types, usages) {
+    await ensureTypesTable(connection);
+    const pool = await createPool(connection);
+    try {
+        for (const type of types) {
+            const typeUsages = usages?.[type.name] || [];
+            await pool.query(`
+                INSERT INTO _relq_types (name, kind, source, usages, updated_at)
+                VALUES ($1, $2, $3, $4, NOW())
+                ON CONFLICT (name) DO UPDATE SET
+                    kind = EXCLUDED.kind,
+                    source = EXCLUDED.source,
+                    usages = EXCLUDED.usages,
+                    updated_at = NOW()
+            `, [type.name, type.kind, type.source, JSON.stringify(typeUsages)]);
+        }
+    }
+    finally {
+        await pool.end();
+    }
+}
+async function removeStaleTypes(connection, currentTypeNames) {
+    const exists = await typesTableExists(connection);
+    if (!exists)
+        return [];
+    const pool = await createPool(connection);
+    try {
+        const result = await pool.query(`
+            DELETE FROM _relq_types
+            WHERE name != ALL($1::text[])
+            RETURNING name
+        `, [currentTypeNames]);
+        return result.rows.map(r => r.name);
+    }
+    finally {
+        await pool.end();
+    }
+}
+function generateTypesFile(types) {
+    if (types.length === 0) {
+        return `/**
+ * Schema Types
+ *
+ * TypeScript type definitions for JSON/JSONB columns.
+ * These types are tracked in the database and synced across workspaces.
+ *
+ * Usage in schema.ts:
+ *   import type { UserMetadata } from './schema.types';
+ *   const users = defineTable('users', {
+ *       metadata: jsonb<UserMetadata>(),
+ *   });
+ */
+
+// Add your type definitions here:
+// export interface UserMetadata {
+//     name: string;
+//     age: number;
+// }
+`;
+    }
+    const interfaceTypes = types.filter(t => t.kind === 'interface');
+    const typeAliases = types.filter(t => t.kind === 'type');
+    let content = `/**
+ * Schema Types
+ *
+ * TypeScript type definitions for JSON/JSONB columns.
+ * These types are tracked in the database and synced across workspaces.
+ *
+ * Generated by: relq pull
+ * Types: ${types.length}
+ */
+
+`;
+    if (interfaceTypes.length > 0) {
+        content += '// =============================================================================\n';
+        content += '// INTERFACES\n';
+        content += '// =============================================================================\n\n';
+        for (const type of interfaceTypes) {
+            content += type.source + '\n\n';
+        }
+    }
+    if (typeAliases.length > 0) {
+        content += '// =============================================================================\n';
+        content += '// TYPE ALIASES\n';
+        content += '// =============================================================================\n\n';
+        for (const type of typeAliases) {
+            content += type.source + '\n\n';
+        }
+    }
+    return content;
+}
+function validateTypesUsage(usedTypes, definedTypes) {
+    const definedSet = new Set(definedTypes);
+    const missingTypes = usedTypes.filter(t => !definedSet.has(t));
+    return {
+        valid: missingTypes.length === 0,
+        missingTypes,
+    };
+}
+function isValidTypesFilePath(filePath) {
+    const basename = path.basename(filePath);
+    return basename.endsWith('.types.ts');
+}
+function getTypesFilePath(schemaPath) {
+    const dir = path.dirname(schemaPath);
+    const basename = path.basename(schemaPath, '.ts');
+    return path.join(dir, `${basename}.types.ts`);
+}
+async function syncTypesToDb(connection, typesFilePath, schemaFilePath) {
+    const result = { added: [], updated: [], removed: [] };
+    if (!fs.existsSync(typesFilePath)) {
+        return result;
+    }
+    const content = fs.readFileSync(typesFilePath, 'utf-8');
+    const localTypes = parseTypesFile(content);
+    const localTypeNames = localTypes.map(t => t.name);
+    let usages;
+    if (schemaFilePath && fs.existsSync(schemaFilePath)) {
+        const schemaContent = fs.readFileSync(schemaFilePath, 'utf-8');
+        usages = extractTypeUsages(schemaContent);
+    }
+    const dbTypes = await getTypesFromDb(connection);
+    const dbTypeMap = new Map(dbTypes.map(t => [t.name, t]));
+    for (const localType of localTypes) {
+        const dbType = dbTypeMap.get(localType.name);
+        if (!dbType) {
+            result.added.push(localType.name);
+        }
+        else if (dbType.source !== localType.source) {
+            result.updated.push(localType.name);
+        }
+    }
+    await storeTypesInDb(connection, localTypes, usages);
+    result.removed = await removeStaleTypes(connection, localTypeNames);
+    return result;
+}
+async function syncTypesFromDb(connection, typesFilePath) {
+    const types = await getTypesFromDb(connection);
+    if (types.length === 0) {
+        if (!fs.existsSync(typesFilePath)) {
+            const content = generateTypesFile([]);
+            fs.writeFileSync(typesFilePath, content);
+            return { typesCount: 0, generated: true };
+        }
+        return { typesCount: 0, generated: false };
+    }
+    const content = generateTypesFile(types);
+    fs.writeFileSync(typesFilePath, content);
+    return { typesCount: types.length, generated: true };
+}

package/dist/esm/cli/commands/add.js

@@ -73,7 +73,7 @@ function parseSchemaFileForComparison(schemaPath) {
                     continue;
                 const tsName = colMatch[1];
                 const type = colMatch[2];
-                const explicitNameMatch = colDef.match(new RegExp(`${type}\\s*\\(['\"]([^'"]+)['\"]`));
+                const explicitNameMatch = colDef.match(new RegExp(`${type}(?:<[^>]+>)?\\s*\\(['\"]([^'"]+)['\"]`));
                 const dbColName = explicitNameMatch ? explicitNameMatch[1] : tsName;
                 tsToDbNameMap.set(tsName, dbColName);
                 let defaultValue = null;
@@ -453,6 +453,12 @@ function parseSchemaFileForComparison(schemaPath) {
             }
         }
     }
+    const schemaDir = path.dirname(schemaPath);
+    const schemaBaseName = path.basename(schemaPath, '.ts');
+    const functionsPath = path.join(schemaDir, `${schemaBaseName}.functions.ts`);
+    const triggersPath = path.join(schemaDir, `${schemaBaseName}.triggers.ts`);
+    const functions = parseFunctionsFile(functionsPath);
+    const triggers = parseTriggersFile(triggersPath);
     return {
         tables,
         enums,
@@ -460,8 +466,8 @@ function parseSchemaFileForComparison(schemaPath) {
         compositeTypes: [],
         sequences: [],
         collations: [],
-        functions: [],
-        triggers: [],
+        functions,
+        triggers,
         policies: [],
         partitions: [],
         foreignServers: [],
@@ -469,6 +475,132 @@ function parseSchemaFileForComparison(schemaPath) {
         extensions,
     };
 }
+function parseFunctionsFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const rawContent = fs.readFileSync(filePath, 'utf-8');
+    const content = stripComments(rawContent);
+    const functions = [];
+    const funcPattern = /pgFunction\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{/g;
+    let funcMatch;
+    while ((funcMatch = funcPattern.exec(content)) !== null) {
+        const funcName = funcMatch[1];
+        const startIdx = funcMatch.index + funcMatch[0].length;
+        let braceCount = 1;
+        let endIdx = startIdx;
+        while (braceCount > 0 && endIdx < content.length) {
+            const char = content[endIdx];
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+            endIdx++;
+        }
+        const optionsBlock = content.substring(startIdx, endIdx - 1);
+        const returnsMatch = optionsBlock.match(/returns:\s*['"]([^'"]+)['"]/);
+        const returnType = returnsMatch ? returnsMatch[1] : 'void';
+        const languageMatch = optionsBlock.match(/language:\s*['"]([^'"]+)['"]/);
+        const language = languageMatch ? languageMatch[1] : 'plpgsql';
+        const volatilityMatch = optionsBlock.match(/volatility:\s*['"]([^'"]+)['"]/);
+        const volatility = volatilityMatch ? volatilityMatch[1] : 'VOLATILE';
+        const argsMatch = optionsBlock.match(/args:\s*\[([^\]]*)\]/s);
+        const argTypes = [];
+        if (argsMatch) {
+            const argsBlock = argsMatch[1];
+            const typeMatches = argsBlock.matchAll(/type:\s*['"]([^'"]+)['"]/g);
+            for (const m of typeMatches) {
+                argTypes.push(m[1]);
+            }
+        }
+        const bodyMatch = optionsBlock.match(/body:\s*`([^`]*)`/s) || optionsBlock.match(/raw:\s*`([^`]*)`/s);
+        const definition = bodyMatch ? bodyMatch[1].trim() : '';
+        functions.push({
+            name: funcName,
+            schema: 'public',
+            returnType,
+            argTypes,
+            language,
+            definition,
+            isAggregate: false,
+            volatility,
+        });
+    }
+    return functions;
+}
+function parseTriggersFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const rawContent = fs.readFileSync(filePath, 'utf-8');
+    const content = stripComments(rawContent);
+    const triggers = [];
+    const trigPattern = /pgTrigger\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{/g;
+    let trigMatch;
+    while ((trigMatch = trigPattern.exec(content)) !== null) {
+        const trigName = trigMatch[1];
+        const startIdx = trigMatch.index + trigMatch[0].length;
+        let braceCount = 1;
+        let endIdx = startIdx;
+        while (braceCount > 0 && endIdx < content.length) {
+            const char = content[endIdx];
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+            endIdx++;
+        }
+        const optionsBlock = content.substring(startIdx, endIdx - 1);
+        let tableName = '';
+        const onSchemaMatch = optionsBlock.match(/on:\s*schema\.(\w+)/);
+        const onStringMatch = optionsBlock.match(/on:\s*['"]([^'"]+)['"]/);
+        if (onSchemaMatch) {
+            tableName = onSchemaMatch[1].replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+        }
+        else if (onStringMatch) {
+            tableName = onStringMatch[1];
+        }
+        let timing = 'BEFORE';
+        let event = 'UPDATE';
+        const beforeMatch = optionsBlock.match(/before:\s*['"]?(\w+)['"]?/);
+        const afterMatch = optionsBlock.match(/after:\s*['"]?(\w+)['"]?/);
+        const insteadOfMatch = optionsBlock.match(/insteadOf:\s*['"]?(\w+)['"]?/);
+        if (beforeMatch) {
+            timing = 'BEFORE';
+            event = beforeMatch[1].toUpperCase();
+        }
+        else if (afterMatch) {
+            timing = 'AFTER';
+            event = afterMatch[1].toUpperCase();
+        }
+        else if (insteadOfMatch) {
+            timing = 'INSTEAD OF';
+            event = insteadOfMatch[1].toUpperCase();
+        }
+        const forEachMatch = optionsBlock.match(/forEach:\s*['"]?(\w+)['"]?/);
+        const forEach = forEachMatch && forEachMatch[1].toUpperCase() === 'STATEMENT' ? 'STATEMENT' : 'ROW';
+        let functionName = '';
+        const execFuncMatch = optionsBlock.match(/execute:\s*functions\.(\w+)/);
+        const execStringMatch = optionsBlock.match(/execute:\s*['"]([^'"]+)['"]/);
+        if (execFuncMatch) {
+            functionName = execFuncMatch[1].replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+        }
+        else if (execStringMatch) {
+            functionName = execStringMatch[1];
+        }
+        triggers.push({
+            name: trigName,
+            tableName,
+            event,
+            timing,
+            forEach,
+            functionName,
+            definition: '',
+            isEnabled: true,
+        });
+    }
+    return triggers;
+}
 function snapshotToDatabaseSchema(snapshot) {
     const tables = (snapshot.tables || []).map(t => ({
         name: t.name,
@@ -509,6 +641,26 @@ function snapshotToDatabaseSchema(snapshot) {
         partitionType: t.partitionType,
         partitionKey: t.partitionKey ? (Array.isArray(t.partitionKey) ? t.partitionKey : [t.partitionKey]) : undefined,
     }));
+    const functions = (snapshot.functions || []).map(f => ({
+        name: f.name,
+        schema: f.schema || 'public',
+        returnType: f.returnType,
+        argTypes: f.argTypes || [],
+        language: f.language,
+        definition: f.body || '',
+        isAggregate: false,
+        volatility: f.volatility || 'VOLATILE',
+    }));
+    const triggers = (snapshot.triggers || []).map(t => ({
+        name: t.name,
+        tableName: t.table,
+        event: t.events?.[0] || 'UPDATE',
+        timing: t.timing,
+        forEach: t.forEach || 'ROW',
+        functionName: t.functionName,
+        definition: '',
+        isEnabled: true,
+    }));
     return {
         tables,
         enums: (snapshot.enums || []).map(e => ({ name: e.name, values: e.values })),
@@ -516,8 +668,8 @@ function snapshotToDatabaseSchema(snapshot) {
         compositeTypes: [],
         sequences: [],
         collations: [],
-        functions: [],
-        triggers: [],
+        functions,
+        triggers,
         policies: [],
         partitions: [],
         foreignServers: [],

package/dist/esm/cli/commands/pull.js

@@ -4,10 +4,11 @@ import { requireValidConfig, getSchemaPath } from "../utils/config-loader.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { introspectedToParsedSchema } from "../utils/ast-transformer.js";
 import { generateTypeScriptFromAST, assignTrackingIds, copyTrackingIdsToNormalized, generateFunctionsFile, generateTriggersFile } from "../utils/ast-codegen.js";
+import { syncTypesFromDb, getTypesFilePath } from "../utils/types-manager.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
 import { createSpinner, colors, formatBytes, formatDuration, fatal, confirm, warning, createMultiProgress } from "../utils/cli-utils.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
-import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, markCommitAsPulled, } from "../utils/repo-manager.js";
+import { isInitialized, initRepository, getHead, saveCommit, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, markCommitAsPulled, getAllCommits, } from "../utils/repo-manager.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
 function toCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
@@ -509,7 +510,18 @@ export async function pullCommand(context) {
                 fatal('Automatic merge failed; fix conflicts and then commit', `${colors.cyan('relq resolve --theirs <name>')}  Take remote version\n${colors.cyan('relq resolve --all-theirs')}     Take all remote\n${colors.cyan('relq pull --force')}             Force overwrite local`);
             }
             if (allChanges.length === 0) {
-                console.log('Already up to date with remote');
+                const localCommits = getAllCommits(projectRoot);
+                const localHashes = new Set(localCommits.map(c => c.hash));
+                const missingCommits = remoteCommits.filter(c => !localHashes.has(c.hash));
+                if (missingCommits.length > 0) {
+                    for (const commit of missingCommits.reverse()) {
+                        saveCommit(commit, projectRoot);
+                    }
+                    console.log(`Synced ${missingCommits.length} commit(s) from remote`);
+                }
+                else {
+                    console.log('Already up to date with remote');
+                }
                 console.log('');
                 return;
             }
@@ -672,6 +684,17 @@ export async function pullCommand(context) {
                 spinner.succeed(`Written ${colors.cyan(triggersPath)} ${colors.muted(`(${formatBytes(trigFileSize)})`)}`);
             }
         }
+        const typesFilePath = getTypesFilePath(schemaPath);
+        const typesResult = await syncTypesFromDb(connection, typesFilePath);
+        if (typesResult.generated) {
+            const typesFileSize = fs.existsSync(typesFilePath) ? fs.statSync(typesFilePath).size : 0;
+            if (typesResult.typesCount > 0) {
+                spinner.succeed(`Written ${colors.cyan(typesFilePath)} ${colors.muted(`(${typesResult.typesCount} types, ${formatBytes(typesFileSize)})`)}`);
+            }
+            else {
+                spinner.succeed(`Created ${colors.cyan(typesFilePath)} ${colors.muted('(empty template)')}`);
+            }
+        }
         const oldSnapshot = loadSnapshot(projectRoot);
         const beforeSchema = oldSnapshot ? {
             extensions: oldSnapshot.extensions?.map(e => e.name) || [],

package/dist/esm/cli/commands/push.js

@@ -6,6 +6,8 @@ import { colors, createSpinner, fatal, confirm, warning } from "../utils/cli-uti
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isEnumIgnored, isDomainIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
 import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, isCommitSyncedWith, markCommitAsPushed, markCommitAsApplied, getConnectionLabel, } from "../utils/repo-manager.js";
+import { syncTypesToDb, getTypesFilePath } from "../utils/types-manager.js";
+import { getSchemaPath } from "../utils/config-loader.js";
 export async function pushCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -110,8 +112,32 @@ export async function pushCommand(context) {
                 }
             }
         }
+        const schemaPath = getSchemaPath(config);
+        const typesFilePath = getTypesFilePath(schemaPath);
+        let typesSynced = false;
+        if (fs.existsSync(typesFilePath) && !dryRun) {
+            spinner.start('Syncing TypeScript types...');
+            const typesResult = await syncTypesToDb(connection, typesFilePath, schemaPath);
+            const totalChanges = typesResult.added.length + typesResult.updated.length + typesResult.removed.length;
+            if (totalChanges > 0) {
+                const parts = [];
+                if (typesResult.added.length > 0)
+                    parts.push(`${typesResult.added.length} added`);
+                if (typesResult.updated.length > 0)
+                    parts.push(`${typesResult.updated.length} updated`);
+                if (typesResult.removed.length > 0)
+                    parts.push(`${typesResult.removed.length} removed`);
+                spinner.succeed(`Synced types: ${parts.join(', ')}`);
+                typesSynced = true;
+            }
+            else {
+                spinner.succeed('Types in sync');
+            }
+        }
         if (toPush.length === 0 && !hasObjectsToDrop) {
-            console.log('Everything up-to-date');
+            if (!typesSynced) {
+                console.log('Everything up-to-date');
+            }
             console.log('');
             return;
         }

package/dist/esm/cli/utils/types-manager.js

@@ -0,0 +1,364 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _relq_types (
+    name TEXT PRIMARY KEY,
+    kind TEXT NOT NULL CHECK (kind IN ('interface', 'type')),
+    source TEXT NOT NULL,
+    usages JSONB DEFAULT '[]',
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_relq_types_kind ON _relq_types(kind);
+`;
+const ADD_USAGES_COLUMN_SQL = `
+ALTER TABLE _relq_types ADD COLUMN IF NOT EXISTS usages JSONB DEFAULT '[]';
+`;
+async function createPool(connection) {
+    const { Pool } = await import("../../addon/pg/index.js");
+    return new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+}
+export async function ensureTypesTable(connection) {
+    const pool = await createPool(connection);
+    try {
+        await pool.query(CREATE_TABLE_SQL);
+        await pool.query(ADD_USAGES_COLUMN_SQL);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function typesTableExists(connection) {
+    const pool = await createPool(connection);
+    try {
+        const result = await pool.query(`
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_name = '_relq_types'
+            ) as exists
+        `);
+        return result.rows[0]?.exists ?? false;
+    }
+    finally {
+        await pool.end();
+    }
+}
+export function parseTypesFile(content) {
+    const definitions = [];
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const interfaceMatch = line.match(/^(?:export\s+)?interface\s+(\w+)(?:<[^>]+>)?\s*\{?\s*$/);
+        if (interfaceMatch) {
+            const name = interfaceMatch[1];
+            const startLine = i;
+            const { endLine, source } = extractBlock(lines, i);
+            definitions.push({ name, kind: 'interface', source, startLine, endLine });
+            i = endLine + 1;
+            continue;
+        }
+        const interfaceExtendsMatch = line.match(/^(?:export\s+)?interface\s+(\w+)(?:<[^>]+>)?\s+extends\s+/);
+        if (interfaceExtendsMatch) {
+            const name = interfaceExtendsMatch[1];
+            const startLine = i;
+            const { endLine, source } = extractBlock(lines, i);
+            definitions.push({ name, kind: 'interface', source, startLine, endLine });
+            i = endLine + 1;
+            continue;
+        }
+        const typeMatch = line.match(/^(?:export\s+)?type\s+(\w+)(?:<[^>]+>)?\s*=\s*/);
+        if (typeMatch) {
+            const name = typeMatch[1];
+            const startLine = i;
+            const { endLine, source } = extractTypeAlias(lines, i);
+            definitions.push({ name, kind: 'type', source, startLine, endLine });
+            i = endLine + 1;
+            continue;
+        }
+        i++;
+    }
+    return definitions;
+}
+function extractBlock(lines, startIdx) {
+    let depth = 0;
+    let started = false;
+    let endIdx = startIdx;
+    for (let i = startIdx; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+            if (char === '{') {
+                depth++;
+                started = true;
+            }
+            else if (char === '}') {
+                depth--;
+            }
+        }
+        if (started && depth === 0) {
+            endIdx = i;
+            break;
+        }
+    }
+    const source = lines.slice(startIdx, endIdx + 1).join('\n');
+    return { endLine: endIdx, source };
+}
+function extractTypeAlias(lines, startIdx) {
+    const firstLine = lines[startIdx];
+    if (firstLine.includes(';') && !firstLine.includes('{')) {
+        return { endLine: startIdx, source: firstLine };
+    }
+    let depth = 0;
+    let endIdx = startIdx;
+    for (let i = startIdx; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+            if (char === '{' || char === '(' || char === '<') {
+                depth++;
+            }
+            else if (char === '}' || char === ')' || char === '>') {
+                depth--;
+            }
+        }
+        if (line.includes(';') && depth === 0) {
+            endIdx = i;
+            break;
+        }
+        if (i > startIdx && depth === 0) {
+            const trimmed = line.trim();
+            if (trimmed === '' || trimmed.startsWith('export ')) {
+                endIdx = i - 1;
+                break;
+            }
+        }
+    }
+    const source = lines.slice(startIdx, endIdx + 1).join('\n');
+    return { endLine: endIdx, source };
+}
+export function extractUsedTypes(schemaContent) {
+    const usedTypes = new Set();
+    const genericPattern = /(?:jsonb|json|varchar|text|char)\s*<\s*([A-Z][a-zA-Z0-9_]*)/g;
+    let match;
+    while ((match = genericPattern.exec(schemaContent)) !== null) {
+        usedTypes.add(match[1]);
+    }
+    return Array.from(usedTypes);
+}
+export function extractTypeUsages(schemaContent) {
+    const usages = {};
+    const tablePattern = /(?:(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*)?defineTable\s*\(\s*['"]([^'"]+)['"]\s*,\s*\{/g;
+    let tableMatch;
+    while ((tableMatch = tablePattern.exec(schemaContent)) !== null) {
+        const varName = tableMatch[1];
+        const tableName = tableMatch[2];
+        const tableStartIdx = tableMatch.index + tableMatch[0].length;
+        let depth = 1;
+        let columnsEndIdx = tableStartIdx;
+        for (let i = tableStartIdx; i < schemaContent.length && depth > 0; i++) {
+            if (schemaContent[i] === '{')
+                depth++;
+            else if (schemaContent[i] === '}')
+                depth--;
+            columnsEndIdx = i;
+        }
+        const columnsBlock = schemaContent.substring(tableStartIdx, columnsEndIdx);
+        const columnPattern = /(\w+)\s*:\s*(?:jsonb|json|varchar|text|char)\s*<\s*([A-Z][a-zA-Z0-9_]*)/g;
+        let columnMatch;
+        while ((columnMatch = columnPattern.exec(columnsBlock)) !== null) {
+            const columnName = columnMatch[1];
+            const typeName = columnMatch[2];
+            const tableRef = varName || tableName;
+            const usage = `${tableRef}.${columnName}`;
+            if (!usages[typeName]) {
+                usages[typeName] = [];
+            }
+            if (!usages[typeName].includes(usage)) {
+                usages[typeName].push(usage);
+            }
+        }
+    }
+    return usages;
+}
+export async function getTypesFromDb(connection) {
+    const exists = await typesTableExists(connection);
+    if (!exists)
+        return [];
+    const pool = await createPool(connection);
+    try {
+        const result = await pool.query(`
+            SELECT name, kind, source, usages, created_at, updated_at
+            FROM _relq_types
+            ORDER BY name
+        `);
+        return result.rows.map(row => ({
+            name: row.name,
+            kind: row.kind,
+            source: row.source,
+            usages: row.usages || [],
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function storeTypesInDb(connection, types, usages) {
+    await ensureTypesTable(connection);
+    const pool = await createPool(connection);
+    try {
+        for (const type of types) {
+            const typeUsages = usages?.[type.name] || [];
+            await pool.query(`
+                INSERT INTO _relq_types (name, kind, source, usages, updated_at)
+                VALUES ($1, $2, $3, $4, NOW())
+                ON CONFLICT (name) DO UPDATE SET
+                    kind = EXCLUDED.kind,
+                    source = EXCLUDED.source,
+                    usages = EXCLUDED.usages,
+                    updated_at = NOW()
+            `, [type.name, type.kind, type.source, JSON.stringify(typeUsages)]);
+        }
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function removeStaleTypes(connection, currentTypeNames) {
+    const exists = await typesTableExists(connection);
+    if (!exists)
+        return [];
+    const pool = await createPool(connection);
+    try {
+        const result = await pool.query(`
+            DELETE FROM _relq_types
+            WHERE name != ALL($1::text[])
+            RETURNING name
+        `, [currentTypeNames]);
+        return result.rows.map(r => r.name);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export function generateTypesFile(types) {
+    if (types.length === 0) {
+        return `/**
+ * Schema Types
+ *
+ * TypeScript type definitions for JSON/JSONB columns.
+ * These types are tracked in the database and synced across workspaces.
+ *
+ * Usage in schema.ts:
+ *   import type { UserMetadata } from "./schema.types.js";
+ *   const users = defineTable('users', {
+ *       metadata: jsonb<UserMetadata>(),
+ *   });
+ */
+
+// Add your type definitions here:
+// export interface UserMetadata {
+//     name: string;
+//     age: number;
+// }
+`;
+    }
+    const interfaceTypes = types.filter(t => t.kind === 'interface');
+    const typeAliases = types.filter(t => t.kind === 'type');
+    let content = `/**
+ * Schema Types
+ *
+ * TypeScript type definitions for JSON/JSONB columns.
+ * These types are tracked in the database and synced across workspaces.
+ *
+ * Generated by: relq pull
+ * Types: ${types.length}
+ */
+
+`;
+    if (interfaceTypes.length > 0) {
+        content += '// =============================================================================\n';
+        content += '// INTERFACES\n';
+        content += '// =============================================================================\n\n';
+        for (const type of interfaceTypes) {
+            content += type.source + '\n\n';
+        }
+    }
+    if (typeAliases.length > 0) {
+        content += '// =============================================================================\n';
+        content += '// TYPE ALIASES\n';
+        content += '// =============================================================================\n\n';
+        for (const type of typeAliases) {
+            content += type.source + '\n\n';
+        }
+    }
+    return content;
+}
+export function validateTypesUsage(usedTypes, definedTypes) {
+    const definedSet = new Set(definedTypes);
+    const missingTypes = usedTypes.filter(t => !definedSet.has(t));
+    return {
+        valid: missingTypes.length === 0,
+        missingTypes,
+    };
+}
+export function isValidTypesFilePath(filePath) {
+    const basename = path.basename(filePath);
+    return basename.endsWith('.types.ts');
+}
+export function getTypesFilePath(schemaPath) {
+    const dir = path.dirname(schemaPath);
+    const basename = path.basename(schemaPath, '.ts');
+    return path.join(dir, `${basename}.types.ts`);
+}
+export async function syncTypesToDb(connection, typesFilePath, schemaFilePath) {
+    const result = { added: [], updated: [], removed: [] };
+    if (!fs.existsSync(typesFilePath)) {
+        return result;
+    }
+    const content = fs.readFileSync(typesFilePath, 'utf-8');
+    const localTypes = parseTypesFile(content);
+    const localTypeNames = localTypes.map(t => t.name);
+    let usages;
+    if (schemaFilePath && fs.existsSync(schemaFilePath)) {
+        const schemaContent = fs.readFileSync(schemaFilePath, 'utf-8');
+        usages = extractTypeUsages(schemaContent);
+    }
+    const dbTypes = await getTypesFromDb(connection);
+    const dbTypeMap = new Map(dbTypes.map(t => [t.name, t]));
+    for (const localType of localTypes) {
+        const dbType = dbTypeMap.get(localType.name);
+        if (!dbType) {
+            result.added.push(localType.name);
+        }
+        else if (dbType.source !== localType.source) {
+            result.updated.push(localType.name);
+        }
+    }
+    await storeTypesInDb(connection, localTypes, usages);
+    result.removed = await removeStaleTypes(connection, localTypeNames);
+    return result;
+}
+export async function syncTypesFromDb(connection, typesFilePath) {
+    const types = await getTypesFromDb(connection);
+    if (types.length === 0) {
+        if (!fs.existsSync(typesFilePath)) {
+            const content = generateTypesFile([]);
+            fs.writeFileSync(typesFilePath, content);
+            return { typesCount: 0, generated: true };
+        }
+        return { typesCount: 0, generated: false };
+    }
+    const content = generateTypesFile(types);
+    fs.writeFileSync(typesFilePath, content);
+    return { typesCount: types.length, generated: true };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relq",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",