relq 1.0.5 → 1.0.6

package/dist/esm/cli/utils/type-generator.js

@@ -5,6 +5,8 @@ const EXCLUDED_FUNCTIONS = [
     'encrypt_iv'
 ];
 function toCamelCase(str) {
+    if (!str)
+        return 'unknown';
     const cleaned = str.replace(/^[_0-9]+/, '');
     return cleaned
         .split('_')
@@ -12,6 +14,8 @@ function toCamelCase(str) {
         .join('');
 }
 function toPascalCase(str) {
+    if (!str)
+        return 'Unknown';
     const cleaned = str.replace(/^[_0-9]+/, '');
     return cleaned
         .split('_')
@@ -19,6 +23,8 @@ function toPascalCase(str) {
         .join('');
 }
 function inferTsTypeFromSqlType(sqlType) {
+    if (!sqlType)
+        return 'string';
     const normalized = sqlType.toLowerCase().replace(/\([^)]*\)/g, '').trim();
     if (['integer', 'int', 'int4', 'smallint', 'int2', 'bigint', 'int8',
         'numeric', 'decimal', 'real', 'float4', 'float8', 'double precision',
@@ -40,6 +46,8 @@ function inferTsTypeFromSqlType(sqlType) {
     return 'string';
 }
 function generateColumnBuilderFromType(sqlType) {
+    if (!sqlType)
+        return 'text()';
     const normalized = sqlType.toLowerCase().trim();
     const paramMatch = normalized.match(/^([a-z_][a-z0-9_\s]*?)(?:\s*\(([^)]+)\))?$/i);
     if (!paramMatch)
@@ -257,6 +265,10 @@ function splitCheckByAnd(expr) {
     return parts;
 }
 function getColumnType(col, enumNames, domainNames, compositeNames) {
+    if (!col.dataType) {
+        console.warn(`Warning: Column ${col.name} has no dataType, defaulting to text`);
+        return 'text()';
+    }
     let pgType = col.dataType.toLowerCase();
     const isArray = pgType.startsWith('_') || pgType.endsWith('[]');
     if (pgType.startsWith('_')) {
@@ -414,12 +426,11 @@ function parseGeneratedExpression(expr, camelCase) {
         const colName = camelCase ? toCamelCase(expr) : expr;
         return `table.${colName}`;
     }
-    const colMatch = expr.match(/[a-z_][a-z0-9_]*/i);
-    if (colMatch) {
-        const colName = camelCase ? toCamelCase(colMatch[0]) : colMatch[0];
-        return `table.${colName}`;
-    }
-    return `table.id /* TODO: Fix expression: ${expr.replace(/\*\//g, '* /')} */`;
+    const escapedExpr = expr
+        .replace(/\\/g, '\\\\')
+        .replace(/`/g, '\\`')
+        .replace(/\$\{/g, '\\${');
+    return `sql\`${escapedExpr}\``;
 }
 function parseArithmeticExpression(expr, camelCase) {
     const tokens = [];
@@ -664,6 +675,13 @@ function formatDefaultValue(val, col, domainMap) {
         return 'true';
     if (cleaned.toLowerCase() === 'false')
         return 'false';
+    if (!col.dataType) {
+        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+            const str = cleaned.slice(1, -1).replace(/'/g, "\\'");
+            return `'${str}'`;
+        }
+        return null;
+    }
     let baseDataType = col.dataType.toLowerCase().replace(/\([^)]*\)$/, '').trim();
     if (domainMap && domainMap.has(baseDataType)) {
         baseDataType = domainMap.get(baseDataType).toLowerCase().replace(/\([^)]*\)$/, '').trim();
@@ -675,7 +693,7 @@ function formatDefaultValue(val, col, domainMap) {
             return `'${cleaned}'`;
         }
         else if (isBigInt) {
-            return `BigInt(${cleaned})`;
+            return `${cleaned}n`;
         }
         return cleaned;
     }
@@ -752,7 +770,7 @@ function formatDefaultValue(val, col, domainMap) {
     }
     return null;
 }
-function generateColumnDef(col, seenColumns, camelCase = true, checkValues, enumNames, domainNames, compositeNames, domainMap) {
+function generateColumnDef(col, seenColumns, camelCase = true, checkInfo, enumNames, domainNames, compositeNames, domainMap) {
     if (seenColumns.has(col.name)) {
         return null;
     }
@@ -774,9 +792,9 @@ function generateColumnDef(col, seenColumns, camelCase = true, checkValues, enum
         typeCall = colType;
     }
     const parts = [typeCall];
-    if (checkValues && checkValues.length > 0) {
-        const quotedValues = checkValues.map(v => `'${v}'`).join(', ');
-        parts.push(`.check(${quotedValues})`);
+    if (checkInfo && checkInfo.values.length > 0) {
+        const quotedValues = checkInfo.values.map(v => `'${v}'`).join(', ');
+        parts.push(`.check('${checkInfo.name}', [${quotedValues}])`);
     }
     if (col.isPrimaryKey) {
         parts.push('.primaryKey()');
@@ -1554,6 +1572,36 @@ function generateCheckConstraints(constraints, camelCase) {
 function generateDefineTable(table, camelCase = true, childPartitions, enumNames, domainNames, compositeNames, domainMap) {
     const tableName = toCamelCase(table.name);
     const seenColumns = new Set();
+    const pkColumns = new Set();
+    const compositePKs = [];
+    const pkConstraints = (table.constraints || []).filter(c => c.type === 'PRIMARY KEY');
+    for (const pk of pkConstraints) {
+        const match = pk.definition.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+        if (match) {
+            const cols = match[1].split(',').map(c => c.trim().replace(/"/g, ''));
+            if (cols.length === 1) {
+                pkColumns.add(cols[0]);
+            }
+            else if (cols.length > 1) {
+                compositePKs.push({ name: pk.name, columns: cols });
+            }
+        }
+    }
+    const uniqueColumns = new Set();
+    const compositeUniques = [];
+    const uniqueConstraints = (table.constraints || []).filter(c => c.type === 'UNIQUE');
+    for (const uq of uniqueConstraints) {
+        const match = uq.definition.match(/UNIQUE\s*\(([^)]+)\)/i);
+        if (match) {
+            const cols = match[1].split(',').map(c => c.trim().replace(/"/g, ''));
+            if (cols.length === 1) {
+                uniqueColumns.add(cols[0]);
+            }
+            else if (cols.length > 1) {
+                compositeUniques.push({ name: uq.name, columns: cols });
+            }
+        }
+    }
     const checkConstraints = (table.constraints || []).filter(c => c.type === 'CHECK');
     const columnChecks = new Map();
     for (const check of checkConstraints) {
@@ -1563,14 +1611,19 @@ function generateDefineTable(table, camelCase = true, childPartitions, enumNames
             const valuesStr = enumMatch[2];
             const values = valuesStr.match(/'([^']+)'/g)?.map(v => v.replace(/'/g, '')) || [];
             if (values.length > 0) {
-                columnChecks.set(colName, values);
+                columnChecks.set(colName, { name: check.name, values });
             }
         }
     }
     const columns = table.columns
         .map(col => {
-        const checkValues = columnChecks.get(col.name);
-        return generateColumnDef(col, seenColumns, camelCase, checkValues, enumNames, domainNames, compositeNames, domainMap);
+        const colWithConstraints = {
+            ...col,
+            isPrimaryKey: pkColumns.has(col.name) ? true : col.isPrimaryKey,
+            isUnique: uniqueColumns.has(col.name) ? true : col.isUnique,
+        };
+        const checkInfo = columnChecks.get(col.name);
+        return generateColumnDef(colWithConstraints, seenColumns, camelCase, checkInfo, enumNames, domainNames, compositeNames, domainMap);
     })
         .filter(Boolean);
     const columnNames = Array.from(seenColumns);
@@ -1578,7 +1631,10 @@ function generateDefineTable(table, camelCase = true, childPartitions, enumNames
     const checkConstraintsFn = table.constraints ? generateCheckConstraints(table.constraints, camelCase) : null;
     const hasPartition = table.isPartitioned && table.partitionType && table.partitionKey?.length;
     const hasChildPartitions = childPartitions && childPartitions.length > 0;
-    if (hasPartition || indexesFn || hasChildPartitions || checkConstraintsFn) {
+    const hasCompositePK = compositePKs.length > 0;
+    const hasCompositeUnique = compositeUniques.length > 0;
+    const hasTableConstraints = hasCompositePK || hasCompositeUnique;
+    if (hasPartition || indexesFn || hasChildPartitions || checkConstraintsFn || hasTableConstraints) {
         const parts = [];
         if (hasPartition) {
             let rawPartitionKey = table.partitionKey || [];
@@ -1631,6 +1687,18 @@ function generateDefineTable(table, camelCase = true, childPartitions, enumNames
             });
             parts.push(`    partitions: (partition) => [\n${partitionLines.join(',\n')},\n    ]`);
         }
+        if (hasTableConstraints) {
+            const constraintLines = [];
+            for (const pk of compositePKs) {
+                const colRefs = pk.columns.map(c => `table.${camelCase ? toCamelCase(c) : c}`).join(', ');
+                constraintLines.push(`        constraint.primaryKey('${pk.name}', ${colRefs})`);
+            }
+            for (const uq of compositeUniques) {
+                const colRefs = uq.columns.map(c => `table.${camelCase ? toCamelCase(c) : c}`).join(', ');
+                constraintLines.push(`        constraint.unique('${uq.name}', ${colRefs})`);
+            }
+            parts.push(`    constraints: (table, constraint) => [\n${constraintLines.join(',\n')},\n    ]`);
+        }
         if (checkConstraintsFn) {
             parts.push(`    checkConstraints: ${checkConstraintsFn.trim()}`);
         }
@@ -1665,6 +1733,10 @@ export function generateTypeScript(schema, options = {}) {
     const imports = new Set(['defineTable']);
     for (const table of tables) {
         for (const col of table.columns) {
+            if (!col.dataType) {
+                console.warn(`Warning: Column ${table.name}.${col.name} has no dataType, skipping`);
+                continue;
+            }
             const rawType = col.dataType.toLowerCase().replace(/^_/, '');
             const pgType = rawType.replace(/\([^)]*\)$/, '').trim();
             if (['int4', 'integer'].includes(pgType))
@@ -1750,6 +1822,15 @@ export function generateTypeScript(schema, options = {}) {
                 if (d.includes("'[]'") || d.includes('array[]'))
                     imports.add('emptyArray');
             }
+            if (col.isGenerated && col.generationExpression) {
+                const expr = col.generationExpression.toLowerCase();
+                const complexFunctions = ['setweight', 'to_tsvector', 'plainto_tsquery', 'ts_rank',
+                    'regexp_replace', 'array_agg', 'string_agg', 'jsonb_build_object',
+                    'jsonb_agg', 'row_to_json', 'json_build_object'];
+                if (complexFunctions.some(f => expr.includes(f))) {
+                    imports.add('sql');
+                }
+            }
         }
     }
     const userFunctions = schema.functions?.filter((f) => !f.name.startsWith('pg_') &&
@@ -1759,6 +1840,9 @@ export function generateTypeScript(schema, options = {}) {
     }
     if (includeTriggers && schema.triggers && schema.triggers.length > 0) {
         imports.add('pgTrigger');
+        if (!includeFunctions) {
+            imports.add('pgFunction');
+        }
     }
     if (schema.sequences && schema.sequences.length > 0) {
         imports.add('pgSequence');
@@ -2014,6 +2098,21 @@ export function generateTypeScript(schema, options = {}) {
         const validTriggers = schema.triggers.filter((t) => tableNames.has(t.tableName.toLowerCase()) &&
             !partitionTableNames.has(t.tableName.toLowerCase()));
         if (validTriggers.length > 0) {
+            const triggerFuncNames = new Set();
+            for (const trigger of validTriggers) {
+                triggerFuncNames.add(trigger.functionName);
+            }
+            if (!includeFunctions && triggerFuncNames.size > 0) {
+                parts.push('// ============================================');
+                parts.push('// Trigger Function References');
+                parts.push('// ============================================');
+                parts.push('');
+                for (const funcName of triggerFuncNames) {
+                    const funcCamel = toCamelCase(funcName);
+                    parts.push(`export const ${funcCamel} = pgFunction('${funcName}', { returns: 'trigger', language: 'plpgsql' });`);
+                }
+                parts.push('');
+            }
             parts.push('// ============================================');
             parts.push('// Database Triggers');
             parts.push('// ============================================');

package/dist/esm/core/relq-client.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from 'node:events';
-import { toPoolConfig } from "../types/config-types.js";
+import { toPoolConfig, isAwsDsqlConfig } from "../types/config-types.js";
+import { getAwsDsqlToken } from "../utils/aws-dsql.js";
 import { SelectBuilder } from "../select/select-builder.js";
 import { AggregateQueryBuilder } from "../select/aggregate-builder.js";
 import { InsertBuilder } from "../insert/insert-builder.js";
@@ -411,8 +412,18 @@ export class Relq {
         }
         this.initPromise = (async () => {
             const { Pool: PgPoolClass, Client: PgClientClass } = await loadPg();
+            let resolvedPassword = this.config.password;
+            if (isAwsDsqlConfig(this.config)) {
+                debugLog(this.config, 'Resolving AWS DSQL token...');
+                resolvedPassword = await getAwsDsqlToken(this.config.aws);
+                debugLog(this.config, 'AWS DSQL token resolved successfully');
+            }
             if (this.usePooling) {
-                this.pool = new PgPoolClass(toPoolConfig(this.config));
+                const poolConfig = toPoolConfig(this.config);
+                if (resolvedPassword) {
+                    poolConfig.password = resolvedPassword;
+                }
+                this.pool = new PgPoolClass(poolConfig);
                 this.setupPoolErrorHandling();
                 this.pool.on('connect', (client) => {
                     this.emitter.emit('connect', client);
@@ -422,14 +433,19 @@ export class Relq {
                 this.pool.on('remove', (client) => this.emitter.emit('remove', client));
             }
             else {
+                const isAws = isAwsDsqlConfig(this.config);
+                const host = isAws ? this.config.aws.hostname : (this.config.host || 'localhost');
+                const port = this.config.aws?.port ?? this.config.port ?? 5432;
+                const user = this.config.aws?.user ?? this.config.user ?? (isAws ? 'admin' : undefined);
+                const ssl = isAws ? (this.config.aws.ssl ?? true) : this.config.ssl;
                 this.client = new PgClientClass({
-                    host: this.config.host || 'localhost',
-                    port: this.config.port || 5432,
+                    host,
+                    port,
                     database: this.config.database,
-                    user: this.config.user,
-                    password: this.config.password,
+                    user,
+                    password: resolvedPassword,
                     connectionString: this.config.connectionString,
-                    ssl: this.config.ssl
+                    ssl
                 });
                 this.client.on('end', () => this.emitter.emit('end'));
                 this.client.on('error', (err) => this.emitter.emit('error', err));

package/dist/esm/schema-definition/column-types.js

@@ -29,6 +29,111 @@ function chainableExpr(sql) {
     };
     return expr;
 }
+export function createFluentGenExpr(sql) {
+    const self = {
+        $sql: sql,
+        $expr: true,
+        coalesce(fallback) {
+            const fallbackSql = typeof fallback === 'object' && '$sql' in fallback
+                ? fallback.$sql
+                : formatGenValue(fallback);
+            return createFluentGenExpr(`COALESCE(${this.$sql}, ${fallbackSql})`);
+        },
+        nullif(value) {
+            return createFluentGenExpr(`NULLIF(${this.$sql}, ${formatGenValue(value)})`);
+        },
+        asText() {
+            return createFluentGenExpr(`(${this.$sql})::TEXT`);
+        },
+        asInteger() {
+            return createFluentGenExpr(`(${this.$sql})::INTEGER`);
+        },
+        asVarchar() {
+            return createFluentGenExpr(`(${this.$sql})::VARCHAR`);
+        },
+        cast(typeName) {
+            return createFluentGenExpr(`(${this.$sql})::${typeName}`);
+        },
+        lower() {
+            return createFluentGenExpr(`LOWER(${this.$sql})`);
+        },
+        upper() {
+            return createFluentGenExpr(`UPPER(${this.$sql})`);
+        },
+        trim() {
+            return createFluentGenExpr(`TRIM(${this.$sql})`);
+        },
+        concat(...parts) {
+            const partsSql = parts.map(p => typeof p === 'object' && '$sql' in p ? p.$sql : formatGenValue(p));
+            return createFluentGenExpr(`(${[this.$sql, ...partsSql].join(' || ')})`);
+        },
+        substring(start, length) {
+            return length !== undefined
+                ? createFluentGenExpr(`SUBSTRING(${this.$sql} FROM ${start} FOR ${length})`)
+                : createFluentGenExpr(`SUBSTRING(${this.$sql} FROM ${start})`);
+        },
+        replace(from, to) {
+            return createFluentGenExpr(`REPLACE(${this.$sql}, '${from.replace(/'/g, "''")}', '${to.replace(/'/g, "''")}')`);
+        },
+        length() {
+            return createFluentGenExpr(`LENGTH(${this.$sql})`);
+        },
+        lpad(len, fill = ' ') {
+            return createFluentGenExpr(`LPAD(${this.$sql}, ${len}, '${fill}')`);
+        },
+        rpad(len, fill = ' ') {
+            return createFluentGenExpr(`RPAD(${this.$sql}, ${len}, '${fill}')`);
+        },
+        toTsvector(config) {
+            return createFluentGenExpr(`TO_TSVECTOR('${config}', ${this.$sql})`);
+        },
+        setWeight(weight) {
+            return createFluentGenExpr(`SETWEIGHT(${this.$sql}, '${weight}')`);
+        },
+        tsvConcat(other) {
+            return createFluentGenExpr(`(${this.$sql} || ${other.$sql})`);
+        },
+        jsonExtract(key) {
+            return createFluentGenExpr(`${this.$sql}->'${key}'`);
+        },
+        jsonExtractText(key) {
+            return createFluentGenExpr(`${this.$sql}->>'${key}'`);
+        },
+        add(value) {
+            return createFluentGenExpr(`(${this.$sql} + ${formatGenValue(value)})`);
+        },
+        subtract(value) {
+            return createFluentGenExpr(`(${this.$sql} - ${formatGenValue(value)})`);
+        },
+        multiply(value) {
+            return createFluentGenExpr(`(${this.$sql} * ${formatGenValue(value)})`);
+        },
+        divide(value) {
+            return createFluentGenExpr(`(${this.$sql} / ${formatGenValue(value)})`);
+        },
+        abs() {
+            return createFluentGenExpr(`ABS(${this.$sql})`);
+        },
+        round(precision) {
+            return precision !== undefined
+                ? createFluentGenExpr(`ROUND(${this.$sql}, ${precision})`)
+                : createFluentGenExpr(`ROUND(${this.$sql})`);
+        },
+        floor() {
+            return createFluentGenExpr(`FLOOR(${this.$sql})`);
+        },
+        ceil() {
+            return createFluentGenExpr(`CEIL(${this.$sql})`);
+        },
+        extract(field) {
+            return createFluentGenExpr(`EXTRACT(${field.toUpperCase()} FROM ${this.$sql})`);
+        },
+        arrayLength(dimension = 1) {
+            return createFluentGenExpr(`ARRAY_LENGTH(${this.$sql}, ${dimension})`);
+        },
+    };
+    return self;
+}
 function createCaseBuilder() {
     const whens = [];
     let elseResult = null;
@@ -119,6 +224,23 @@ const generatedFnMethods = {
     arrayPosition: (arr, elem) => chainableExpr(`ARRAY_POSITION(${arr.$sql}, ${formatGenValue(elem)})`),
     md5: (col) => chainableExpr(`MD5(${col.$sql})`),
     sha256: (col) => chainableExpr(`ENCODE(SHA256(${col.$sql}::BYTEA), 'hex')`),
+    col: (name, alias) => chainableExpr(alias ? `"${alias}"."${name}"` : `"${name}"`),
+    cast: (value, typeName) => chainableExpr(`(${formatGenValue(value)})::${typeName}`),
+    func: (name, ...args) => chainableExpr(`${name.toUpperCase()}(${args.map(formatGenValue).join(', ')})`),
+    sql: (expression) => chainableExpr(expression),
+    op: (left, operator, right) => chainableExpr(`(${formatGenValue(left)} ${operator} ${formatGenValue(right)})`),
+    setweight: (tsvector, weight) => chainableExpr(`SETWEIGHT(${tsvector.$sql}, '${weight}')`),
+    setWeight: (tsvector, weight) => chainableExpr(`SETWEIGHT(${tsvector.$sql}, '${weight}')`),
+    asVarchar: (col) => chainableExpr(`(${col.$sql})::VARCHAR`),
+    textConcat: (left, right) => chainableExpr(`(${formatGenValue(left)} || ${formatGenValue(right)})`),
+    tsMatch: (left, right) => chainableExpr(`(${left.$sql} @@ ${right.$sql})`),
+    compare: (left, op, right) => chainableExpr(`(${formatGenValue(left)} ${op} ${formatGenValue(right)})`),
+    regex: (value, op, pattern) => chainableExpr(`(${value.$sql} ${op} ${formatGenValue(pattern)})`),
+    and: (...args) => chainableExpr(`(${args.map(a => a.$sql).join(' AND ')})`),
+    or: (...args) => chainableExpr(`(${args.map(a => a.$sql).join(' OR ')})`),
+    not: (arg) => chainableExpr(`(NOT ${arg.$sql})`),
+    isNull: (col) => chainableExpr(`(${col.$sql} IS NULL)`),
+    isNotNull: (col) => chainableExpr(`(${col.$sql} IS NOT NULL)`),
 };
 const generatedFn = new Proxy(function (col) {
     return chainableExpr(col.$sql);
@@ -159,21 +281,19 @@ function createColumn(type) {
             config.$references = { table, column, ...options };
             return Object.assign(this, { $references: config.$references });
         },
-        check(...values) {
-            if (values.length === 1 && /[<>=!()&|+\-*/ ]/.test(values[0])) {
-                config.$check = values[0];
-                return Object.assign(this, { $check: values[0] });
-            }
-            const expression = `IN ('${values.join("', '")}')`;
+        check(name, values) {
+            const expression = `${name} IN ('${values.join("', '")}')`;
+            config.$checkName = name;
             config.$checkValues = values;
             config.$check = expression;
-            return Object.assign(this, { $check: expression, $checkValues: values });
+            return Object.assign(this, { $check: expression, $checkName: name, $checkValues: values });
         },
-        checkNot(...values) {
-            const expression = `NOT IN ('${values.join("', '")}')`;
+        checkNot(name, values) {
+            const expression = `${name} NOT IN ('${values.join("', '")}')`;
+            config.$checkNotName = name;
             config.$checkNotValues = values;
             config.$checkNot = expression;
-            return Object.assign(this, { $checkNot: expression, $checkNotValues: values });
+            return Object.assign(this, { $checkNot: expression, $checkNotName: name, $checkNotValues: values });
         },
         generatedAs(expression, stored = true) {
             config.$generated = { expression, stored };
@@ -234,6 +354,14 @@ function createColumn(type) {
             config.$dimensions = d;
             config.$type = `VECTOR(${d})`;
             return Object.assign(this, { $dimensions: d, $type: config.$type });
+        },
+        comment(text) {
+            config.$comment = text;
+            return Object.assign(this, { $comment: text });
+        },
+        $id(trackingId) {
+            config.$trackingId = trackingId;
+            return Object.assign(this, { $trackingId: trackingId });
         }
     };
     return builder;
@@ -700,10 +828,16 @@ export function generateCompositeTypeSQL(composite) {
 }
 export const customType = (typeName, columnName) => createColumnWithName(typeName, columnName);
 export const enumType = (name, values, columnName) => {
-    const col = createColumnWithName(name, columnName);
-    col.$enumValues = values;
+    const enumName = typeof name === 'string' ? name : name.name;
+    const enumValues = typeof name === 'string' ? (values || []) : name.values;
+    const col = createColumnWithName(enumName, columnName);
+    col.$enumValues = enumValues;
     return col;
 };
+export const domainType = (domainDef, columnName) => {
+    const domainName = typeof domainDef === 'string' ? domainDef : domainDef.$domainName;
+    return createColumnWithName(domainName, columnName);
+};
 export const compositeType = (typeName, columnName) => createColumnWithName(typeName, columnName);
 export const SQL_BRAND = Symbol.for('relq.sql.brand');
 function sqlExpr(sql) {

package/dist/esm/schema-definition/defaults.js

@@ -0,0 +1,69 @@
+function createDefault(sql) {
+    return { $sql: sql, $isDefault: true };
+}
+export const DEFAULT = {
+    genRandomUuid: () => createDefault('gen_random_uuid()'),
+    uuidGenerateV4: () => createDefault('uuid_generate_v4()'),
+    uuidGenerateV1: () => createDefault('uuid_generate_v1()'),
+    uuidGenerateV1mc: () => createDefault('uuid_generate_v1mc()'),
+    uuidNil: () => createDefault('uuid_nil()'),
+    now: () => createDefault('NOW()'),
+    currentTimestamp: () => createDefault('CURRENT_TIMESTAMP'),
+    currentDate: () => createDefault('CURRENT_DATE'),
+    currentTime: () => createDefault('CURRENT_TIME'),
+    localTimestamp: () => createDefault('LOCALTIMESTAMP'),
+    localTime: () => createDefault('LOCALTIME'),
+    transactionTimestamp: () => createDefault('transaction_timestamp()'),
+    statementTimestamp: () => createDefault('statement_timestamp()'),
+    clockTimestamp: () => createDefault('clock_timestamp()'),
+    timeofday: () => createDefault('timeofday()'),
+    interval: (value) => createDefault(`INTERVAL '${value}'`),
+    currentUser: () => createDefault('CURRENT_USER'),
+    sessionUser: () => createDefault('SESSION_USER'),
+    user: () => createDefault('USER'),
+    currentSchema: () => createDefault('current_schema()'),
+    currentDatabase: () => createDefault('current_database()'),
+    currentCatalog: () => createDefault('current_catalog'),
+    inetClientAddr: () => createDefault('inet_client_addr()'),
+    inetClientPort: () => createDefault('inet_client_port()'),
+    inetServerAddr: () => createDefault('inet_server_addr()'),
+    inetServerPort: () => createDefault('inet_server_port()'),
+    pgBackendPid: () => createDefault('pg_backend_pid()'),
+    nextval: (sequenceName) => createDefault(`nextval('${sequenceName}'::regclass)`),
+    currval: (sequenceName) => createDefault(`currval('${sequenceName}'::regclass)`),
+    lastval: () => createDefault('lastval()'),
+    random: () => createDefault('random()'),
+    pi: () => createDefault('pi()'),
+    emptyString: () => createDefault("''"),
+    emptyObject: () => createDefault("'{}'::jsonb"),
+    emptyJson: () => createDefault("'{}'::json"),
+    emptyJsonb: () => createDefault("'{}'::jsonb"),
+    emptyArray: () => createDefault("'{}'"),
+    emptyArrayOf: (type) => createDefault(`ARRAY[]::${type}[]`),
+    true: () => createDefault('TRUE'),
+    false: () => createDefault('FALSE'),
+    null: () => createDefault('NULL'),
+    zero: () => createDefault('0'),
+    one: () => createDefault('1'),
+    negativeOne: () => createDefault('-1'),
+    string: (value) => createDefault(`'${value.replace(/'/g, "''")}'`),
+    number: (value) => createDefault(String(value)),
+    integer: (value) => createDefault(String(Math.floor(value))),
+    decimal: (value, precision) => createDefault(precision !== undefined ? value.toFixed(precision) : String(value)),
+    cast: (value, type) => createDefault(`${typeof value === 'string' ? `'${value}'` : value}::${type}`),
+    emptyTsvector: () => createDefault("''::tsvector"),
+    point: (x, y) => createDefault(`point(${x}, ${y})`),
+    inet: (address) => createDefault(`'${address}'::inet`),
+    cidr: (network) => createDefault(`'${network}'::cidr`),
+    macaddr: (address) => createDefault(`'${address}'::macaddr`),
+    emptyInt4range: () => createDefault("'empty'::int4range"),
+    emptyInt8range: () => createDefault("'empty'::int8range"),
+    emptyNumrange: () => createDefault("'empty'::numrange"),
+    emptyTsrange: () => createDefault("'empty'::tsrange"),
+    emptyTstzrange: () => createDefault("'empty'::tstzrange"),
+    emptyDaterange: () => createDefault("'empty'::daterange"),
+    emptyHstore: () => createDefault("''::hstore"),
+    emptyBytea: () => createDefault("'\\x'::bytea"),
+    money: (value) => createDefault(`'${value}'::money`),
+    zeroMoney: () => createDefault("'0'::money"),
+};

package/dist/esm/schema-definition/index.js

@@ -3,8 +3,11 @@ export { defineTable } from "./table-definition.js";
 export { sqlFunctions, pgExtensions, getSql, createWhereBuilder, createGeneratedExprBuilder, createTableColumnRefs, expressionBuilder, createExpressionBuilder, } from "./sql-expressions.js";
 export { parseCreateTable, generateSchemaCode, introspectSQL, introspectMultiple } from "./introspection.js";
 export { one, many, manyToMany } from "./relations.js";
+export { pgRelations, defineRelations, generateReferencesSQL, actionCodeToString, stringToActionCode, matchCodeToString, } from "./pg-relations.js";
 export { pgEnum, generateEnumSQL, dropEnumSQL, addEnumValueSQL } from "./pg-enum.js";
 export { pgFunction, generateFunctionSQL, dropFunctionSQL, isFunctionConfig, } from "./pg-function.js";
 export { pgTrigger, generateTriggerSQL, dropTriggerSQL, isTriggerConfig, } from "./pg-trigger.js";
 export { pgSequence, generateSequenceSQL, dropSequenceSQL, isSequenceConfig, } from "./pg-sequence.js";
+export { pgView, pgMaterializedView, viewToSQL, materializedViewToSQL, } from "./pg-view.js";
 export { partitionStrategyFactory, generatePartitionBySQL, generateChildPartitionSQL, } from "./partitions.js";
+export { DEFAULT } from "./defaults.js";

package/dist/esm/schema-definition/introspection.js

@@ -472,7 +472,7 @@ export function generateSchemaCode(table, options) {
             modifiers.push('.unique()');
         }
         if (col.default !== undefined) {
-            const defaultVal = formatDefaultValue(col.default);
+            const defaultVal = formatDefaultValue(col.default, col.type);
             modifiers.push(`.default(${defaultVal})`);
         }
         if (col.references) {
@@ -577,7 +577,7 @@ function toPascalCase(str) {
 function escapeString(str) {
     return str.replace(/'/g, "\\'").replace(/\\/g, '\\\\');
 }
-function formatDefaultValue(value) {
+function formatDefaultValue(value, colType) {
     const upper = value.toUpperCase().trim();
     if (upper === 'NOW()' || upper === 'CURRENT_TIMESTAMP' ||
         upper === 'CURRENT_DATE' || upper === 'CURRENT_TIME') {
@@ -592,7 +592,11 @@ function formatDefaultValue(value) {
     if (upper === 'NULL') {
         return 'null';
     }
-    if (/^-?\d+(\.\d+)?$/.test(value)) {
+    const isBigint = colType?.toLowerCase().startsWith('bigint');
+    if (/^-?\d+$/.test(value)) {
+        return isBigint ? `${value}n` : value;
+    }
+    if (/^-?\d+\.\d+$/.test(value)) {
         return value;
     }
     if (value.includes('(')) {