relq 1.0.34 → 1.0.36

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

@@ -258,6 +258,7 @@ async function pullCommand(context) {
             { id: 'collations', label: 'collations', status: 'pending', count: 0 },
             { id: 'foreign_servers', label: 'foreign servers', status: 'pending', count: 0 },
             { id: 'foreign_tables', label: 'foreign tables', status: 'pending', count: 0 },
+            { id: 'types', label: 'types', status: 'pending', count: 0 },
         ];
         progress.setItems(progressItems);
         progress.start();
@@ -268,6 +269,9 @@ async function pullCommand(context) {
                 progress.updateItem(update.step, { status: update.status, count: update.count });
             },
         });
+        progress.updateItem('types', { status: 'fetching', count: 0 });
+        const typesForProgress = await (0, types_manager_1.getTypesFromDb)(connection);
+        progress.updateItem('types', { status: 'done', count: typesForProgress.length });
         progress.complete();
         console.log('');
         const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
@@ -563,6 +567,38 @@ async function pullCommand(context) {
                     console.log(`Synced ${typesResult.typesCount} type(s) from remote`);
                     hasSynced = true;
                 }
+                if (typesForProgress.length > 0 && fs.existsSync(schemaPath)) {
+                    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+                    const schemaBaseName = path.basename(schemaPath, '.ts');
+                    const typesImportPattern = new RegExp(`from\\s+['"]\\./${schemaBaseName}\\.types['"]`);
+                    const hasTypesImport = typesImportPattern.test(schemaContent);
+                    const typesWithUsages = typesForProgress.filter(t => t.usages && t.usages.length > 0);
+                    if (typesWithUsages.length > 0 && !hasTypesImport) {
+                        console.log(`Applying ${typesWithUsages.length} type(s) to schema...`);
+                        const columnTypeMap = {};
+                        for (const typeDef of typesForProgress) {
+                            if (typeDef.usages) {
+                                for (const usage of typeDef.usages) {
+                                    columnTypeMap[usage] = typeDef.name;
+                                }
+                            }
+                        }
+                        const parsedSchema = await (0, ast_transformer_1.introspectedToParsedSchema)(dbSchema);
+                        (0, ast_codegen_1.assignTrackingIds)(parsedSchema);
+                        const typesImportPath = `./${schemaBaseName}.types`;
+                        const typescript = (0, ast_codegen_1.generateTypeScriptFromAST)(parsedSchema, {
+                            camelCase: config.generate?.camelCase ?? true,
+                            importPath: 'relq/schema-builder',
+                            includeFunctions: false,
+                            includeTriggers: false,
+                            columnTypeMap,
+                            typesImportPath,
+                        });
+                        fs.writeFileSync(schemaPath, typescript, 'utf-8');
+                        console.log(`Updated ${cli_utils_1.colors.cyan(schemaPath)} with type annotations`);
+                        hasSynced = true;
+                    }
+                }
                 if (!hasSynced) {
                     console.log('Already up to date with remote');
                 }
@@ -682,11 +718,23 @@ async function pullCommand(context) {
         spinner.start('Generating TypeScript schema...');
         const parsedSchema = await (0, ast_transformer_1.introspectedToParsedSchema)(dbSchema);
         (0, ast_codegen_1.assignTrackingIds)(parsedSchema);
+        const columnTypeMap = {};
+        for (const typeDef of typesForProgress) {
+            if (typeDef.usages) {
+                for (const usage of typeDef.usages) {
+                    columnTypeMap[usage] = typeDef.name;
+                }
+            }
+        }
+        const schemaBaseName = path.basename(schemaPath, '.ts');
+        const typesImportPath = `./${schemaBaseName}.types`;
         const typescript = (0, ast_codegen_1.generateTypeScriptFromAST)(parsedSchema, {
             camelCase: config.generate?.camelCase ?? true,
             importPath: 'relq/schema-builder',
             includeFunctions: false,
             includeTriggers: false,
+            columnTypeMap,
+            typesImportPath,
         });
         spinner.succeed('Generated TypeScript schema');
         const schemaDir = path.dirname(schemaPath);

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

@@ -151,6 +151,28 @@ 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(schemaPath)) {
+            spinner.start('Validating types configuration...');
+            const validationErrors = await (0, types_manager_1.validateTypesConfiguration)(schemaPath, typesFilePath);
+            if (validationErrors.length > 0) {
+                spinner.fail('Types validation failed');
+                console.log('');
+                for (const err of validationErrors) {
+                    console.log(`${cli_utils_1.colors.red('error:')} ${err.message}`);
+                    if (err.details && err.details.length > 0) {
+                        for (const detail of err.details) {
+                            console.log(`   ${cli_utils_1.colors.muted('→')} ${detail}`);
+                        }
+                    }
+                    if (err.hint) {
+                        console.log(`   ${cli_utils_1.colors.cyan('hint:')} ${err.hint}`);
+                    }
+                    console.log('');
+                }
+                (0, cli_utils_1.fatal)('Types configuration is invalid', `Fix the issues above and try again.\nTypes must be defined in ${cli_utils_1.colors.cyan(path.basename(typesFilePath))} to enable database syncing.`);
+            }
+            spinner.succeed('Types configuration valid');
+        }
         if (fs.existsSync(typesFilePath) && !dryRun) {
             spinner.start('Syncing TypeScript types...');
             const typesResult = await (0, types_manager_1.syncTypesToDb)(connection, typesFilePath, schemaPath);

package/dist/cjs/cli/utils/ast-codegen.cjs

@@ -168,7 +168,7 @@ function getExplicitFKName(constraintName, tableName, columnName) {
     }
     return constraintName;
 }
-function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOverride) {
+function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOverride, genericTypeName) {
     const colName = useCamelCase ? (0, utils_1.toCamelCase)(col.name) : col.name;
     const commentSuffix = col.comment ? `.comment('${(0, utils_1.escapeString)(col.comment)}')` : '';
     let line;
@@ -183,15 +183,20 @@ function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOver
     }
     else {
         let typeBuilder;
+        const isJsonType = normalizedType === 'json' || normalizedType === 'jsonb';
+        const genericSuffix = isJsonType && genericTypeName ? `<${genericTypeName}>` : '';
         if (useCamelCase && colName !== col.name) {
             const builderInfo = (0, type_map_1.getColumnBuilderWithInfo)(col.type, col.typeParams);
-            typeBuilder = `${builderInfo.builderName}('${col.name}')`;
+            typeBuilder = `${builderInfo.builderName}${genericSuffix}('${col.name}')`;
             if (builderInfo.length != null) {
                 typeBuilder += `.length(${builderInfo.length})`;
             }
         }
         else {
             typeBuilder = (0, type_map_1.getColumnBuilder)(col.type, col.typeParams);
+            if (genericSuffix) {
+                typeBuilder = typeBuilder.replace(/(\w+)\(/, `$1${genericSuffix}(`);
+            }
         }
         if (col.isArray) {
             typeBuilder = `${typeBuilder}.array()`;
@@ -447,7 +452,7 @@ function generatePartitionCode(child, partitionType, useCamelCase) {
     needsSqlImport = true;
     return `        partition('${childName}').in([sql\`${(0, utils_1.escapeString)(bound)}\`])`;
 }
-function generateTableCode(table, useCamelCase, enumNames, domainNames) {
+function generateTableCode(table, useCamelCase, enumNames, domainNames, columnTypeMap = {}) {
     const tableName = useCamelCase ? (0, utils_1.toCamelCase)(table.name) : table.name;
     const parts = [];
     const tableComment = table.comment ? `    comment: '${(0, utils_1.escapeString)(table.comment)}'` : null;
@@ -499,7 +504,11 @@ function generateTableCode(table, useCamelCase, enumNames, domainNames) {
             isUnique: col.isUnique || uniqueColumns.has(col.name) || uniqueColumns.has(normalizedColName),
         };
     });
-    const columnLines = updatedColumns.map(col => generateColumnCode(col, useCamelCase, enumNames, domainNames, columnChecks.get(col.name)));
+    const columnLines = updatedColumns.map(col => {
+        const columnKey = `${table.name}.${col.name}`;
+        const genericTypeName = columnTypeMap[columnKey];
+        return generateColumnCode(col, useCamelCase, enumNames, domainNames, columnChecks.get(col.name), genericTypeName);
+    });
     const optionParts = [];
     if (table.isPartitioned && table.partitionType && table.partitionKey?.length) {
         const partCol = useCamelCase ? (0, utils_1.toCamelCase)(table.partitionKey[0]) : table.partitionKey[0];
@@ -715,7 +724,7 @@ function generateTriggerCode(trigger, useCamelCase, functionNames) {
     return parts.join('\n');
 }
 function generateTypeScriptFromAST(schema, options = {}) {
-    const { camelCase = true, importPath = 'relq/schema-builder', includeEnums = true, includeDomains = true, includeTables = true, includeFunctions = true, includeTriggers = true, } = options;
+    const { camelCase = true, importPath = 'relq/schema-builder', includeEnums = true, includeDomains = true, includeTables = true, includeFunctions = true, includeTriggers = true, columnTypeMap = {}, typesImportPath, } = options;
     const parts = [];
     parts.push('/**');
     parts.push(' * Auto-generated by Relq CLI (AST-based)');
@@ -750,7 +759,7 @@ function generateTypeScriptFromAST(schema, options = {}) {
     for (const table of sortedTables) {
         if (table.partitionOf)
             continue;
-        const code = generateTableCode(table, camelCase, enumNames, domainNames);
+        const code = generateTableCode(table, camelCase, enumNames, domainNames, columnTypeMap);
         tableCodeParts.push(code);
         for (const col of table.columns) {
             if (enumNames.has(col.type.toLowerCase())) {
@@ -807,6 +816,11 @@ function generateTypeScriptFromAST(schema, options = {}) {
     parts.push(`    ${imports.join(',\n    ')},`);
     parts.push(`    type RelqDatabaseSchema,`);
     parts.push(`} from '${importPath}';`);
+    const usedTypeNames = new Set(Object.values(columnTypeMap));
+    if (usedTypeNames.size > 0 && typesImportPath) {
+        const typeNames = Array.from(usedTypeNames).sort();
+        parts.push(`import { ${typeNames.join(', ')} } from '${typesImportPath}';`);
+    }
     parts.push('');
     if (needsPgExtensions) {
         parts.push('// =============================================================================');
@@ -861,7 +875,7 @@ function generateTypeScriptFromAST(schema, options = {}) {
         for (const table of sortedTables) {
             if (table.partitionOf)
                 continue;
-            parts.push(generateTableCode(table, camelCase, enumNames, domainNames));
+            parts.push(generateTableCode(table, camelCase, enumNames, domainNames, columnTypeMap));
             parts.push('');
         }
     }

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

@@ -43,6 +43,10 @@ exports.storeTypesInDb = storeTypesInDb;
 exports.removeStaleTypes = removeStaleTypes;
 exports.generateTypesFile = generateTypesFile;
 exports.validateTypesUsage = validateTypesUsage;
+exports.validateSchemaForInlineTypes = validateSchemaForInlineTypes;
+exports.validateTypeImports = validateTypeImports;
+exports.validateTypesFileSyntax = validateTypesFileSyntax;
+exports.validateTypesConfiguration = validateTypesConfiguration;
 exports.isValidTypesFilePath = isValidTypesFilePath;
 exports.getTypesFilePath = getTypesFilePath;
 exports.syncTypesToDb = syncTypesToDb;
@@ -207,7 +211,6 @@ function extractTypeUsages(schemaContent) {
     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;
@@ -220,13 +223,15 @@ function extractTypeUsages(schemaContent) {
             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;
+        const columnPattern = /(\w+)\s*:\s*(?:jsonb|json|varchar|text|char)\s*<\s*([A-Z][a-zA-Z0-9_]*)\s*>\s*\(([^)]*)\)/g;
         let columnMatch;
         while ((columnMatch = columnPattern.exec(columnsBlock)) !== null) {
-            const columnName = columnMatch[1];
+            const tsColumnName = columnMatch[1];
             const typeName = columnMatch[2];
-            const tableRef = varName || tableName;
-            const usage = `${tableRef}.${columnName}`;
+            const argsBlock = columnMatch[3];
+            const explicitNameMatch = argsBlock.match(/^\s*['"]([^'"]+)['"]/);
+            const sqlColumnName = explicitNameMatch ? explicitNameMatch[1] : tsColumnName;
+            const usage = `${tableName}.${sqlColumnName}`;
             if (!usages[typeName]) {
                 usages[typeName] = [];
             }
@@ -360,6 +365,174 @@ function validateTypesUsage(usedTypes, definedTypes) {
         missingTypes,
     };
 }
+function validateSchemaForInlineTypes(schemaContent) {
+    const lines = schemaContent.split('\n');
+    const inlineTypes = [];
+    const excludePatterns = [
+        /RelqDatabaseSchema/,
+        /typeof\s+schema/,
+        /Infer</,
+    ];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const interfaceMatch = line.match(/^(?:export\s+)?interface\s+(\w+)\s*(?:<[^>]*>)?\s*\{/);
+        if (interfaceMatch) {
+            let hasBody = false;
+            for (let j = i + 1; j < lines.length && j < i + 50; j++) {
+                const bodyLine = lines[j].trim();
+                if (bodyLine === '}')
+                    break;
+                if (bodyLine && !bodyLine.startsWith('//') && !bodyLine.startsWith('/*')) {
+                    hasBody = true;
+                    break;
+                }
+            }
+            if (hasBody) {
+                inlineTypes.push(`interface ${interfaceMatch[1]} (line ${i + 1})`);
+            }
+            continue;
+        }
+        const typeMatch = line.match(/^(?:export\s+)?type\s+(\w+)(?:<[^>]*>)?\s*=\s*(.+)/);
+        if (typeMatch) {
+            const typeName = typeMatch[1];
+            const typeValue = typeMatch[2];
+            const isExcluded = excludePatterns.some(pattern => pattern.test(typeValue));
+            if (isExcluded) {
+                continue;
+            }
+            const isObjectType = typeValue.trim().startsWith('{');
+            const isUnionType = typeValue.includes('|') && !typeValue.includes('<');
+            const isLiteralType = /^['"]/.test(typeValue.trim());
+            if (isObjectType || isUnionType || isLiteralType) {
+                inlineTypes.push(`type ${typeName} (line ${i + 1})`);
+            }
+        }
+    }
+    if (inlineTypes.length > 0) {
+        return {
+            type: 'inline_type',
+            message: 'Type definitions found in schema file',
+            hint: 'Move type definitions to schema.types.ts to enable database syncing and team collaboration.',
+            details: inlineTypes,
+        };
+    }
+    return null;
+}
+function validateTypeImports(schemaContent, schemaPath) {
+    const typesFileName = path.basename(getTypesFilePath(schemaPath));
+    const wrongImports = [];
+    const importPattern = /import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importPattern.exec(schemaContent)) !== null) {
+        const imports = match[1];
+        const source = match[2];
+        if (source.endsWith('.types') || source.includes(typesFileName.replace('.ts', ''))) {
+            continue;
+        }
+        if (source.startsWith('relq') || source.startsWith('@') || !source.startsWith('.')) {
+            continue;
+        }
+        const importedItems = imports.split(',').map(s => s.trim());
+        const typeImports = importedItems.filter(item => {
+            const name = item.split(' as ')[0].trim();
+            return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+        });
+        if (typeImports.length > 0) {
+            wrongImports.push(`${typeImports.join(', ')} from '${source}'`);
+        }
+    }
+    if (wrongImports.length > 0) {
+        return {
+            type: 'wrong_import',
+            message: 'Types imported from incorrect location',
+            hint: `Database-synced types must be defined in ${typesFileName}. Move these type definitions there and update the import.`,
+            details: wrongImports,
+        };
+    }
+    return null;
+}
+async function validateTypesFileSyntax(typesFilePath) {
+    if (!fs.existsSync(typesFilePath)) {
+        return null;
+    }
+    const content = fs.readFileSync(typesFilePath, 'utf-8');
+    const errors = [];
+    let braceCount = 0;
+    let inInterface = false;
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^(?:export\s+)?interface\s+\w+/.test(line)) {
+            inInterface = true;
+        }
+        for (const char of line) {
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+        }
+        if (inInterface && braceCount === 0) {
+            inInterface = false;
+        }
+    }
+    if (braceCount !== 0) {
+        errors.push('Unbalanced braces detected - check for missing { or }');
+    }
+    const invalidPatterns = [
+        { pattern: /interface\s+\d/, message: 'Interface name cannot start with a number' },
+        { pattern: /type\s+\d/, message: 'Type name cannot start with a number' },
+        { pattern: /:\s*;/, message: 'Missing type annotation before semicolon' },
+    ];
+    for (const { pattern, message } of invalidPatterns) {
+        if (pattern.test(content)) {
+            errors.push(message);
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            type: 'typescript_error',
+            message: 'TypeScript syntax errors in types file',
+            hint: 'Fix the syntax errors in your types file before pushing.',
+            details: errors,
+        };
+    }
+    return null;
+}
+async function validateTypesConfiguration(schemaPath, typesFilePath) {
+    const errors = [];
+    if (!fs.existsSync(schemaPath)) {
+        return errors;
+    }
+    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+    const inlineError = validateSchemaForInlineTypes(schemaContent);
+    if (inlineError) {
+        errors.push(inlineError);
+    }
+    const importError = validateTypeImports(schemaContent, schemaPath);
+    if (importError) {
+        errors.push(importError);
+    }
+    const syntaxError = await validateTypesFileSyntax(typesFilePath);
+    if (syntaxError) {
+        errors.push(syntaxError);
+    }
+    if (fs.existsSync(typesFilePath)) {
+        const typesContent = fs.readFileSync(typesFilePath, 'utf-8');
+        const usedTypes = extractUsedTypes(schemaContent);
+        const parsedTypes = parseTypesFile(typesContent);
+        const definedTypeNames = parsedTypes.map(t => t.name);
+        const usageValidation = validateTypesUsage(usedTypes, definedTypeNames);
+        if (!usageValidation.valid) {
+            errors.push({
+                type: 'missing_type',
+                message: 'Types used in schema but not defined in types file',
+                hint: `Add these type definitions to ${path.basename(typesFilePath)}.`,
+                details: usageValidation.missingTypes,
+            });
+        }
+    }
+    return errors;
+}
 function isValidTypesFilePath(filePath) {
     const basename = path.basename(filePath);
     return basename.endsWith('.types.ts');

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

@@ -4,7 +4,7 @@ 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 { syncTypesFromDb, getTypesFilePath, getTypesFromDb } 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";
@@ -222,6 +222,7 @@ export async function pullCommand(context) {
             { id: 'collations', label: 'collations', status: 'pending', count: 0 },
             { id: 'foreign_servers', label: 'foreign servers', status: 'pending', count: 0 },
             { id: 'foreign_tables', label: 'foreign tables', status: 'pending', count: 0 },
+            { id: 'types', label: 'types', status: 'pending', count: 0 },
         ];
         progress.setItems(progressItems);
         progress.start();
@@ -232,6 +233,9 @@ export async function pullCommand(context) {
                 progress.updateItem(update.step, { status: update.status, count: update.count });
             },
         });
+        progress.updateItem('types', { status: 'fetching', count: 0 });
+        const typesForProgress = await getTypesFromDb(connection);
+        progress.updateItem('types', { status: 'done', count: typesForProgress.length });
         progress.complete();
         console.log('');
         const ignorePatterns = loadRelqignore(projectRoot);
@@ -527,6 +531,38 @@ export async function pullCommand(context) {
                     console.log(`Synced ${typesResult.typesCount} type(s) from remote`);
                     hasSynced = true;
                 }
+                if (typesForProgress.length > 0 && fs.existsSync(schemaPath)) {
+                    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+                    const schemaBaseName = path.basename(schemaPath, '.ts');
+                    const typesImportPattern = new RegExp(`from\\s+['"]\\./${schemaBaseName}\\.types['"]`);
+                    const hasTypesImport = typesImportPattern.test(schemaContent);
+                    const typesWithUsages = typesForProgress.filter(t => t.usages && t.usages.length > 0);
+                    if (typesWithUsages.length > 0 && !hasTypesImport) {
+                        console.log(`Applying ${typesWithUsages.length} type(s) to schema...`);
+                        const columnTypeMap = {};
+                        for (const typeDef of typesForProgress) {
+                            if (typeDef.usages) {
+                                for (const usage of typeDef.usages) {
+                                    columnTypeMap[usage] = typeDef.name;
+                                }
+                            }
+                        }
+                        const parsedSchema = await introspectedToParsedSchema(dbSchema);
+                        assignTrackingIds(parsedSchema);
+                        const typesImportPath = `./${schemaBaseName}.types`;
+                        const typescript = generateTypeScriptFromAST(parsedSchema, {
+                            camelCase: config.generate?.camelCase ?? true,
+                            importPath: 'relq/schema-builder',
+                            includeFunctions: false,
+                            includeTriggers: false,
+                            columnTypeMap,
+                            typesImportPath,
+                        });
+                        fs.writeFileSync(schemaPath, typescript, 'utf-8');
+                        console.log(`Updated ${colors.cyan(schemaPath)} with type annotations`);
+                        hasSynced = true;
+                    }
+                }
                 if (!hasSynced) {
                     console.log('Already up to date with remote');
                 }
@@ -646,11 +682,23 @@ export async function pullCommand(context) {
         spinner.start('Generating TypeScript schema...');
         const parsedSchema = await introspectedToParsedSchema(dbSchema);
         assignTrackingIds(parsedSchema);
+        const columnTypeMap = {};
+        for (const typeDef of typesForProgress) {
+            if (typeDef.usages) {
+                for (const usage of typeDef.usages) {
+                    columnTypeMap[usage] = typeDef.name;
+                }
+            }
+        }
+        const schemaBaseName = path.basename(schemaPath, '.ts');
+        const typesImportPath = `./${schemaBaseName}.types`;
         const typescript = generateTypeScriptFromAST(parsedSchema, {
             camelCase: config.generate?.camelCase ?? true,
             importPath: 'relq/schema-builder',
             includeFunctions: false,
             includeTriggers: false,
+            columnTypeMap,
+            typesImportPath,
         });
         spinner.succeed('Generated TypeScript schema');
         const schemaDir = path.dirname(schemaPath);

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

@@ -6,7 +6,7 @@ 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 { syncTypesToDb, getTypesFilePath, validateTypesConfiguration } from "../utils/types-manager.js";
 import { getSchemaPath } from "../utils/config-loader.js";
 export async function pushCommand(context) {
     const { config, flags } = context;
@@ -115,6 +115,28 @@ export async function pushCommand(context) {
         const schemaPath = getSchemaPath(config);
         const typesFilePath = getTypesFilePath(schemaPath);
         let typesSynced = false;
+        if (fs.existsSync(schemaPath)) {
+            spinner.start('Validating types configuration...');
+            const validationErrors = await validateTypesConfiguration(schemaPath, typesFilePath);
+            if (validationErrors.length > 0) {
+                spinner.fail('Types validation failed');
+                console.log('');
+                for (const err of validationErrors) {
+                    console.log(`${colors.red('error:')} ${err.message}`);
+                    if (err.details && err.details.length > 0) {
+                        for (const detail of err.details) {
+                            console.log(`   ${colors.muted('→')} ${detail}`);
+                        }
+                    }
+                    if (err.hint) {
+                        console.log(`   ${colors.cyan('hint:')} ${err.hint}`);
+                    }
+                    console.log('');
+                }
+                fatal('Types configuration is invalid', `Fix the issues above and try again.\nTypes must be defined in ${colors.cyan(path.basename(typesFilePath))} to enable database syncing.`);
+            }
+            spinner.succeed('Types configuration valid');
+        }
         if (fs.existsSync(typesFilePath) && !dryRun) {
             spinner.start('Syncing TypeScript types...');
             const typesResult = await syncTypesToDb(connection, typesFilePath, schemaPath);

package/dist/esm/cli/utils/ast-codegen.js

@@ -160,7 +160,7 @@ function getExplicitFKName(constraintName, tableName, columnName) {
     }
     return constraintName;
 }
-function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOverride) {
+function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOverride, genericTypeName) {
     const colName = useCamelCase ? toCamelCase(col.name) : col.name;
     const commentSuffix = col.comment ? `.comment('${escapeString(col.comment)}')` : '';
     let line;
@@ -175,15 +175,20 @@ function generateColumnCode(col, useCamelCase, enumNames, domainNames, checkOver
     }
     else {
         let typeBuilder;
+        const isJsonType = normalizedType === 'json' || normalizedType === 'jsonb';
+        const genericSuffix = isJsonType && genericTypeName ? `<${genericTypeName}>` : '';
         if (useCamelCase && colName !== col.name) {
             const builderInfo = getColumnBuilderWithInfo(col.type, col.typeParams);
-            typeBuilder = `${builderInfo.builderName}('${col.name}')`;
+            typeBuilder = `${builderInfo.builderName}${genericSuffix}('${col.name}')`;
             if (builderInfo.length != null) {
                 typeBuilder += `.length(${builderInfo.length})`;
             }
         }
         else {
             typeBuilder = getColumnBuilder(col.type, col.typeParams);
+            if (genericSuffix) {
+                typeBuilder = typeBuilder.replace(/(\w+)\(/, `$1${genericSuffix}(`);
+            }
         }
         if (col.isArray) {
             typeBuilder = `${typeBuilder}.array()`;
@@ -439,7 +444,7 @@ function generatePartitionCode(child, partitionType, useCamelCase) {
     needsSqlImport = true;
     return `        partition('${childName}').in([sql\`${escapeString(bound)}\`])`;
 }
-function generateTableCode(table, useCamelCase, enumNames, domainNames) {
+function generateTableCode(table, useCamelCase, enumNames, domainNames, columnTypeMap = {}) {
     const tableName = useCamelCase ? toCamelCase(table.name) : table.name;
     const parts = [];
     const tableComment = table.comment ? `    comment: '${escapeString(table.comment)}'` : null;
@@ -491,7 +496,11 @@ function generateTableCode(table, useCamelCase, enumNames, domainNames) {
             isUnique: col.isUnique || uniqueColumns.has(col.name) || uniqueColumns.has(normalizedColName),
         };
     });
-    const columnLines = updatedColumns.map(col => generateColumnCode(col, useCamelCase, enumNames, domainNames, columnChecks.get(col.name)));
+    const columnLines = updatedColumns.map(col => {
+        const columnKey = `${table.name}.${col.name}`;
+        const genericTypeName = columnTypeMap[columnKey];
+        return generateColumnCode(col, useCamelCase, enumNames, domainNames, columnChecks.get(col.name), genericTypeName);
+    });
     const optionParts = [];
     if (table.isPartitioned && table.partitionType && table.partitionKey?.length) {
         const partCol = useCamelCase ? toCamelCase(table.partitionKey[0]) : table.partitionKey[0];
@@ -707,7 +716,7 @@ function generateTriggerCode(trigger, useCamelCase, functionNames) {
     return parts.join('\n');
 }
 export function generateTypeScriptFromAST(schema, options = {}) {
-    const { camelCase = true, importPath = 'relq/schema-builder', includeEnums = true, includeDomains = true, includeTables = true, includeFunctions = true, includeTriggers = true, } = options;
+    const { camelCase = true, importPath = 'relq/schema-builder', includeEnums = true, includeDomains = true, includeTables = true, includeFunctions = true, includeTriggers = true, columnTypeMap = {}, typesImportPath, } = options;
     const parts = [];
     parts.push('/**');
     parts.push(' * Auto-generated by Relq CLI (AST-based)');
@@ -742,7 +751,7 @@ export function generateTypeScriptFromAST(schema, options = {}) {
     for (const table of sortedTables) {
         if (table.partitionOf)
             continue;
-        const code = generateTableCode(table, camelCase, enumNames, domainNames);
+        const code = generateTableCode(table, camelCase, enumNames, domainNames, columnTypeMap);
         tableCodeParts.push(code);
         for (const col of table.columns) {
             if (enumNames.has(col.type.toLowerCase())) {
@@ -799,6 +808,11 @@ export function generateTypeScriptFromAST(schema, options = {}) {
     parts.push(`    ${imports.join(',\n    ')},`);
     parts.push(`    type RelqDatabaseSchema,`);
     parts.push(`} from '${importPath}';`);
+    const usedTypeNames = new Set(Object.values(columnTypeMap));
+    if (usedTypeNames.size > 0 && typesImportPath) {
+        const typeNames = Array.from(usedTypeNames).sort();
+        parts.push(`import { ${typeNames.join(', ')} } from '${typesImportPath}';`);
+    }
     parts.push('');
     if (needsPgExtensions) {
         parts.push('// =============================================================================');
@@ -853,7 +867,7 @@ export function generateTypeScriptFromAST(schema, options = {}) {
         for (const table of sortedTables) {
             if (table.partitionOf)
                 continue;
-            parts.push(generateTableCode(table, camelCase, enumNames, domainNames));
+            parts.push(generateTableCode(table, camelCase, enumNames, domainNames, columnTypeMap));
             parts.push('');
         }
     }

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

@@ -158,7 +158,6 @@ export function extractTypeUsages(schemaContent) {
     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;
@@ -171,13 +170,15 @@ export function extractTypeUsages(schemaContent) {
             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;
+        const columnPattern = /(\w+)\s*:\s*(?:jsonb|json|varchar|text|char)\s*<\s*([A-Z][a-zA-Z0-9_]*)\s*>\s*\(([^)]*)\)/g;
         let columnMatch;
         while ((columnMatch = columnPattern.exec(columnsBlock)) !== null) {
-            const columnName = columnMatch[1];
+            const tsColumnName = columnMatch[1];
             const typeName = columnMatch[2];
-            const tableRef = varName || tableName;
-            const usage = `${tableRef}.${columnName}`;
+            const argsBlock = columnMatch[3];
+            const explicitNameMatch = argsBlock.match(/^\s*['"]([^'"]+)['"]/);
+            const sqlColumnName = explicitNameMatch ? explicitNameMatch[1] : tsColumnName;
+            const usage = `${tableName}.${sqlColumnName}`;
             if (!usages[typeName]) {
                 usages[typeName] = [];
             }
@@ -311,6 +312,174 @@ export function validateTypesUsage(usedTypes, definedTypes) {
         missingTypes,
     };
 }
+export function validateSchemaForInlineTypes(schemaContent) {
+    const lines = schemaContent.split('\n');
+    const inlineTypes = [];
+    const excludePatterns = [
+        /RelqDatabaseSchema/,
+        /typeof\s+schema/,
+        /Infer</,
+    ];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const interfaceMatch = line.match(/^(?:export\s+)?interface\s+(\w+)\s*(?:<[^>]*>)?\s*\{/);
+        if (interfaceMatch) {
+            let hasBody = false;
+            for (let j = i + 1; j < lines.length && j < i + 50; j++) {
+                const bodyLine = lines[j].trim();
+                if (bodyLine === '}')
+                    break;
+                if (bodyLine && !bodyLine.startsWith('//') && !bodyLine.startsWith('/*')) {
+                    hasBody = true;
+                    break;
+                }
+            }
+            if (hasBody) {
+                inlineTypes.push(`interface ${interfaceMatch[1]} (line ${i + 1})`);
+            }
+            continue;
+        }
+        const typeMatch = line.match(/^(?:export\s+)?type\s+(\w+)(?:<[^>]*>)?\s*=\s*(.+)/);
+        if (typeMatch) {
+            const typeName = typeMatch[1];
+            const typeValue = typeMatch[2];
+            const isExcluded = excludePatterns.some(pattern => pattern.test(typeValue));
+            if (isExcluded) {
+                continue;
+            }
+            const isObjectType = typeValue.trim().startsWith('{');
+            const isUnionType = typeValue.includes('|') && !typeValue.includes('<');
+            const isLiteralType = /^['"]/.test(typeValue.trim());
+            if (isObjectType || isUnionType || isLiteralType) {
+                inlineTypes.push(`type ${typeName} (line ${i + 1})`);
+            }
+        }
+    }
+    if (inlineTypes.length > 0) {
+        return {
+            type: 'inline_type',
+            message: 'Type definitions found in schema file',
+            hint: 'Move type definitions to schema.types.ts to enable database syncing and team collaboration.',
+            details: inlineTypes,
+        };
+    }
+    return null;
+}
+export function validateTypeImports(schemaContent, schemaPath) {
+    const typesFileName = path.basename(getTypesFilePath(schemaPath));
+    const wrongImports = [];
+    const importPattern = /import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importPattern.exec(schemaContent)) !== null) {
+        const imports = match[1];
+        const source = match[2];
+        if (source.endsWith('.types') || source.includes(typesFileName.replace('.ts', ''))) {
+            continue;
+        }
+        if (source.startsWith('relq') || source.startsWith('@') || !source.startsWith('.')) {
+            continue;
+        }
+        const importedItems = imports.split(',').map(s => s.trim());
+        const typeImports = importedItems.filter(item => {
+            const name = item.split(' as ')[0].trim();
+            return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+        });
+        if (typeImports.length > 0) {
+            wrongImports.push(`${typeImports.join(', ')} from '${source}'`);
+        }
+    }
+    if (wrongImports.length > 0) {
+        return {
+            type: 'wrong_import',
+            message: 'Types imported from incorrect location',
+            hint: `Database-synced types must be defined in ${typesFileName}. Move these type definitions there and update the import.`,
+            details: wrongImports,
+        };
+    }
+    return null;
+}
+export async function validateTypesFileSyntax(typesFilePath) {
+    if (!fs.existsSync(typesFilePath)) {
+        return null;
+    }
+    const content = fs.readFileSync(typesFilePath, 'utf-8');
+    const errors = [];
+    let braceCount = 0;
+    let inInterface = false;
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^(?:export\s+)?interface\s+\w+/.test(line)) {
+            inInterface = true;
+        }
+        for (const char of line) {
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+        }
+        if (inInterface && braceCount === 0) {
+            inInterface = false;
+        }
+    }
+    if (braceCount !== 0) {
+        errors.push('Unbalanced braces detected - check for missing { or }');
+    }
+    const invalidPatterns = [
+        { pattern: /interface\s+\d/, message: 'Interface name cannot start with a number' },
+        { pattern: /type\s+\d/, message: 'Type name cannot start with a number' },
+        { pattern: /:\s*;/, message: 'Missing type annotation before semicolon' },
+    ];
+    for (const { pattern, message } of invalidPatterns) {
+        if (pattern.test(content)) {
+            errors.push(message);
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            type: 'typescript_error',
+            message: 'TypeScript syntax errors in types file',
+            hint: 'Fix the syntax errors in your types file before pushing.',
+            details: errors,
+        };
+    }
+    return null;
+}
+export async function validateTypesConfiguration(schemaPath, typesFilePath) {
+    const errors = [];
+    if (!fs.existsSync(schemaPath)) {
+        return errors;
+    }
+    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+    const inlineError = validateSchemaForInlineTypes(schemaContent);
+    if (inlineError) {
+        errors.push(inlineError);
+    }
+    const importError = validateTypeImports(schemaContent, schemaPath);
+    if (importError) {
+        errors.push(importError);
+    }
+    const syntaxError = await validateTypesFileSyntax(typesFilePath);
+    if (syntaxError) {
+        errors.push(syntaxError);
+    }
+    if (fs.existsSync(typesFilePath)) {
+        const typesContent = fs.readFileSync(typesFilePath, 'utf-8');
+        const usedTypes = extractUsedTypes(schemaContent);
+        const parsedTypes = parseTypesFile(typesContent);
+        const definedTypeNames = parsedTypes.map(t => t.name);
+        const usageValidation = validateTypesUsage(usedTypes, definedTypeNames);
+        if (!usageValidation.valid) {
+            errors.push({
+                type: 'missing_type',
+                message: 'Types used in schema but not defined in types file',
+                hint: `Add these type definitions to ${path.basename(typesFilePath)}.`,
+                details: usageValidation.missingTypes,
+            });
+        }
+    }
+    return errors;
+}
 export function isValidTypesFilePath(filePath) {
     const basename = path.basename(filePath);
     return basename.endsWith('.types.ts');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relq",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",
@@ -61,5 +61,7 @@
     "sql-formatter": "^15.6.12",
     "strip-comments": "^2.0.1"
   },
-  "devDependencies": {}
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
 }