@relq/orm 0.1.0

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

@@ -0,0 +1,270 @@
+import { EventEmitter } from 'node:events';
+import { RelqConnectionError } from "../shared/errors/relq-errors.js";
+import { ConditionCollector } from "../condition/condition-collector.js";
+import { ConnectedCTEBuilder, ConnectedRawQueryBuilder, INTERNAL, debugLog } from "./helpers/index.js";
+import { ConnectedScalarSelectBuilder } from "../select/scalar-select-builder.js";
+import { buildColumnMappings, transformToDbColumns, transformFromDbColumns, transformResultsFromDb, hasColumnMapping } from "./shared/column-mapping.js";
+import { validateData } from "./shared/validation.js";
+import { createTableAccessor } from "./shared/table-accessor.js";
+import { registerInstance, unregisterInstance } from "./shared/cleanup.js";
+export class RelqBase {
+    config;
+    schema;
+    emitter = new EventEmitter();
+    _defaultErrorHandler = () => { };
+    columnMappings = new Map();
+    initialized = false;
+    initPromise;
+    _isClosed = false;
+    constructor(schema, config) {
+        this.config = config;
+        this.schema = schema;
+        this.emitter.on('error', this._defaultErrorHandler);
+        if (schema) {
+            const log = config.logLevel === 'debug'
+                ? (...args) => debugLog(config, ...args)
+                : undefined;
+            buildColumnMappings(schema, this.columnMappings, log);
+        }
+        registerInstance(this);
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            await this._initialize();
+            this.initialized = true;
+        })();
+        return this.initPromise;
+    }
+    _transformToDbColumns(tableName, data) {
+        return transformToDbColumns(tableName, data, this.columnMappings);
+    }
+    _transformFromDbColumns(tableName, data) {
+        return transformFromDbColumns(tableName, data, this.columnMappings);
+    }
+    _transformResultsFromDb(tableName, rows) {
+        return transformResultsFromDb(tableName, rows, this.columnMappings);
+    }
+    _hasColumnMapping() {
+        return hasColumnMapping(this.columnMappings);
+    }
+    _validateData(tableName, data, operation) {
+        validateData(tableName, data, operation, this.columnMappings, this.config);
+    }
+    _getSchema() {
+        if (!this.schema)
+            return undefined;
+        return this.schema.tables || this.schema;
+    }
+    _getRelations() {
+        return this.config.relations;
+    }
+    _getTableDef(tableKey) {
+        const schema = this._getSchema();
+        if (!schema)
+            return undefined;
+        return schema[tableKey];
+    }
+    get [INTERNAL]() {
+        return {
+            executeSelect: this._executeSelect.bind(this),
+            executeSelectOne: this._executeSelectOne.bind(this),
+            executeCount: this._executeCount.bind(this),
+            executeRun: this._executeRun.bind(this),
+            executeQuery: this._executeQuery.bind(this),
+            transformToDbColumns: this._transformToDbColumns.bind(this),
+            transformFromDbColumns: this._transformFromDbColumns.bind(this),
+            transformResultsFromDb: this._transformResultsFromDb.bind(this),
+            hasColumnMapping: this._hasColumnMapping.bind(this),
+            getClientForCursor: this._acquireClient.bind(this),
+            validateData: this._validateData.bind(this),
+            getSchema: this._getSchema.bind(this),
+            getRelations: this._getRelations.bind(this),
+            getTableDef: this._getTableDef.bind(this)
+        };
+    }
+    async _executeQuery(sql) {
+        if (!sql || typeof sql !== 'string' || sql.trim() === '') {
+            throw new RelqConnectionError(`Invalid SQL query: ${sql === null ? 'null' : sql === undefined ? 'undefined' : 'empty string'}`);
+        }
+        await this.ensureInitialized();
+        const startTime = performance.now();
+        const retryConfig = this.config.retry;
+        if (!retryConfig) {
+            const result = await this._query(sql);
+            return { result, duration: performance.now() - startTime };
+        }
+        const opts = typeof retryConfig === 'object'
+            ? { maxRetries: retryConfig.maxRetries ?? 3, initialDelayMs: retryConfig.initialDelayMs ?? 250, maxDelayMs: retryConfig.maxDelayMs ?? 5000 }
+            : { maxRetries: 3, initialDelayMs: 250, maxDelayMs: 5000 };
+        let lastError;
+        for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+            try {
+                const result = await this._query(sql);
+                return { result, duration: performance.now() - startTime };
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < opts.maxRetries && isTransientError(error)) {
+                    const delay = Math.min(opts.initialDelayMs * 2 ** attempt, opts.maxDelayMs);
+                    debugLog(this.config, `Transient error (attempt ${attempt + 1}/${opts.maxRetries}), retrying in ${delay}ms: ${error.code || error.message}`);
+                    await sleep(delay);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError;
+    }
+    buildMetadata(result, duration) {
+        return {
+            rowCount: result.rowCount,
+            command: result.command,
+            duration,
+            fields: result.fields
+        };
+    }
+    async _executeSelect(sql, tableName) {
+        const { result, duration } = await this._executeQuery(sql);
+        const rows = tableName
+            ? this._transformResultsFromDb(tableName, result.rows)
+            : result.rows;
+        return {
+            data: rows,
+            metadata: this.buildMetadata(result, duration)
+        };
+    }
+    async _executeSelectOne(sql, tableName) {
+        const { result, duration } = await this._executeQuery(sql);
+        const row = result.rows[0]
+            ? (tableName ? this._transformFromDbColumns(tableName, result.rows[0]) : result.rows[0])
+            : null;
+        return {
+            data: row,
+            metadata: this.buildMetadata(result, duration)
+        };
+    }
+    async _executeCount(sql) {
+        const { result, duration } = await this._executeQuery(sql);
+        const count = result.rows[0]?.count
+            ? parseInt(result.rows[0].count, 10)
+            : 0;
+        return {
+            count,
+            metadata: this.buildMetadata(result, duration)
+        };
+    }
+    async _executeRun(sql) {
+        const { result, duration } = await this._executeQuery(sql);
+        return {
+            success: true,
+            metadata: this.buildMetadata(result, duration)
+        };
+    }
+    get table() {
+        return createTableAccessor(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new ConnectedRawQueryBuilder(query, params, this);
+    }
+    async transaction(callback) {
+        const { executeTransaction } = await import("./helpers/ConnectedTransactionBuilder.js");
+        return executeTransaction(this, callback);
+    }
+    with(name, query) {
+        return new ConnectedCTEBuilder(this).with(name, query);
+    }
+    async ctAs(tableName, query, options = {}) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        const temp = options.temporary ? 'TEMPORARY ' : '';
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        const sql = `CREATE ${temp}TABLE ${ifNotExists}"${tableName}" AS ${queryStr}`;
+        await this[INTERNAL].executeQuery(sql);
+    }
+    async explain(query, options = {}) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        const parts = ['EXPLAIN'];
+        if (options.format)
+            parts.push(`(FORMAT ${options.format.toUpperCase()}`);
+        if (options.analyze)
+            parts.push(options.format ? ', ANALYZE' : '(ANALYZE');
+        if (options.verbose)
+            parts.push(options.format || options.analyze ? ', VERBOSE' : '(VERBOSE');
+        if (options.format || options.analyze || options.verbose)
+            parts.push(')');
+        const sql = `${parts.join(' ')} ${queryStr}`;
+        const { result } = await this._executeQuery(sql);
+        if (options.format === 'json') {
+            return result.rows;
+        }
+        return result.rows.map((r) => r['QUERY PLAN'] || Object.values(r)[0]).join('\n');
+    }
+    scalar(scalars) {
+        const schema = this._getSchema();
+        return new ConnectedScalarSelectBuilder(scalars, schema, {
+            executeSelectOne: this[INTERNAL].executeSelect.bind(this),
+            hasColumnMapping: this._hasColumnMapping.bind(this),
+            transformToDbColumns: this._transformToDbColumns.bind(this)
+        });
+    }
+    where(_tableName) {
+        return new ConditionCollector();
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        this.emitter.once(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+        return this;
+    }
+    async close() {
+        if (!this.initialized || this._isClosed)
+            return;
+        try {
+            await this._close();
+            this._isClosed = true;
+            unregisterInstance(this);
+        }
+        catch (error) {
+            console.error('Error closing database connection:', error);
+            throw error;
+        }
+    }
+    get closed() {
+        return this._isClosed;
+    }
+}
+const TRANSIENT_NETWORK_CODES = new Set([
+    'ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'ESERVFAIL',
+    'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'EHOSTUNREACH',
+    'CONNECTION_LOST', 'PROTOCOL_CONNECTION_LOST',
+]);
+const TRANSIENT_PG_CODES = new Set([
+    '40P01',
+    '40001',
+    '08006',
+    '08001',
+    '08004',
+    '57P01',
+    '57P03',
+]);
+function isTransientError(error) {
+    if (TRANSIENT_NETWORK_CODES.has(error.code))
+        return true;
+    if (error.cause && TRANSIENT_NETWORK_CODES.has(error.cause.code))
+        return true;
+    if (TRANSIENT_PG_CODES.has(error.code))
+        return true;
+    return false;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,48 @@
+import { RelqPostgres } from "./pg-family/pg-client/index.js";
+import { RelqNile } from "./pg-family/nile-client/index.js";
+import { RelqDsql } from "./pg-family/dsql-client/index.js";
+import { RelqCockroachDB } from "./pg-family/cockroachdb-client/index.js";
+import { RelqConfigError } from "../shared/errors/relq-errors.js";
+class RelqImpl {
+    constructor(schema, dialect, options) {
+        const opts = options ?? {};
+        switch (dialect) {
+            case 'postgres':
+                return new RelqPostgres(schema, { ...opts, dialect: 'postgres' });
+            case 'nile':
+                return new RelqNile(schema, { ...opts, dialect: 'nile' });
+            case 'cockroachdb':
+                return new RelqCockroachDB(schema, { ...opts, dialect: 'cockroachdb' });
+            case 'awsdsql':
+                return new RelqDsql(schema, { ...opts, dialect: 'awsdsql' });
+            case 'sqlite':
+                throw new RelqConfigError(`Dialect "sqlite" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'turso':
+                throw new RelqConfigError(`Dialect "turso" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'mysql':
+                throw new RelqConfigError(`Dialect "mysql" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'mariadb':
+                throw new RelqConfigError(`Dialect "mariadb" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'planetscale':
+                throw new RelqConfigError(`Dialect "planetscale" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'xata':
+                throw new RelqConfigError(`Dialect "xata" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            default:
+                throw new RelqConfigError(`Unknown dialect: "${dialect}". ` +
+                    `Supported dialects: postgres, nile, cockroachdb, awsdsql, sqlite, turso, mysql, mariadb, planetscale, xata`, { field: 'dialect', value: dialect });
+        }
+    }
+}
+export const Relq = RelqImpl;
+export { RelqPostgres } from "./pg-family/pg-client/index.js";
+export { RelqNile } from "./pg-family/nile-client/index.js";
+export { RelqDsql } from "./pg-family/dsql-client/index.js";
+export { RelqCockroachDB } from "./pg-family/cockroachdb-client/index.js";
+export { RelqBase } from "./relq-base.js";
+export default Relq;

package/dist/esm/core/shared/cleanup.js

@@ -0,0 +1,27 @@
+import process from 'node:process';
+export const activeInstances = new Set();
+let cleanupHandlersRegistered = false;
+export function registerGlobalCleanupHandlers() {
+    if (cleanupHandlersRegistered)
+        return;
+    if (typeof process === 'undefined' || !process.on)
+        return;
+    try {
+        if (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers')
+            return;
+    }
+    catch { }
+    process.on('beforeExit', async () => {
+        if (activeInstances.size === 0)
+            return;
+        await Promise.all(Array.from(activeInstances).map(instance => instance.close().catch(err => console.error('Error closing database connection:', err))));
+    });
+    cleanupHandlersRegistered = true;
+}
+export function registerInstance(instance) {
+    activeInstances.add(instance);
+    registerGlobalCleanupHandlers();
+}
+export function unregisterInstance(instance) {
+    activeInstances.delete(instance);
+}

package/dist/esm/core/shared/column-mapping.js

@@ -0,0 +1,90 @@
+import { serializeValue, deserializeValue } from "../../utils/type-coercion.js";
+export function buildColumnMappings(schema, mappings, debugLog) {
+    if (!schema || typeof schema !== 'object')
+        return;
+    const tables = schema.tables || schema;
+    for (const [tableName, tableDef] of Object.entries(tables)) {
+        if (!tableDef || typeof tableDef !== 'object')
+            continue;
+        const columns = tableDef.$columns;
+        if (!columns || typeof columns !== 'object')
+            continue;
+        const propToDb = new Map();
+        const dbToProp = new Map();
+        const propToType = new Map();
+        const propToCheckValues = new Map();
+        const propToValidate = new Map();
+        const propToFields = new Map();
+        for (const [propName, colDef] of Object.entries(columns)) {
+            const dbColName = colDef?.$columnName ?? propName;
+            const colType = colDef?.$sqlType || (typeof colDef?.$type === 'string' ? colDef.$type : undefined) || 'TEXT';
+            propToDb.set(propName, dbColName);
+            dbToProp.set(dbColName, propName);
+            propToType.set(propName, colType);
+            if (debugLog) {
+                debugLog(`buildColumnMappings: ${tableName}.${propName} -> type=${colType}, $validate=${!!colDef?.$validate}, $fields=${!!colDef?.$fields}, $checkValues=${!!colDef?.$checkValues}`);
+            }
+            if (colDef?.$checkValues && Array.isArray(colDef.$checkValues)) {
+                propToCheckValues.set(propName, colDef.$checkValues);
+            }
+            if (colDef?.$validate && typeof colDef.$validate === 'function') {
+                propToValidate.set(propName, colDef.$validate);
+            }
+            if (colDef?.$fields && typeof colDef.$fields === 'object') {
+                propToFields.set(propName, colDef.$fields);
+            }
+        }
+        const dbTableName = tableDef.$name ?? tableName;
+        mappings.set(dbTableName, {
+            propToDb,
+            dbToProp,
+            propToType,
+            propToCheckValues,
+            propToValidate,
+            propToFields
+        });
+    }
+}
+export function transformToDbColumns(tableName, data, mappings) {
+    const mapping = mappings.get(tableName);
+    if (!mapping)
+        return data;
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const dbColName = mapping.propToDb.get(key) ?? key;
+        const colType = mapping.propToType.get(key);
+        if (colType && typeof colType === 'string') {
+            result[dbColName] = serializeValue(value, colType);
+        }
+        else {
+            result[dbColName] = value;
+        }
+    }
+    return result;
+}
+export function transformFromDbColumns(tableName, data, mappings) {
+    const mapping = mappings.get(tableName);
+    if (!mapping)
+        return data;
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        const propName = mapping.dbToProp.get(key) ?? key;
+        const colType = mapping.propToType.get(propName);
+        if (colType && typeof colType === 'string') {
+            result[propName] = deserializeValue(value, colType);
+        }
+        else {
+            result[propName] = value;
+        }
+    }
+    return result;
+}
+export function transformResultsFromDb(tableName, rows, mappings) {
+    const mapping = mappings.get(tableName);
+    if (!mapping)
+        return rows;
+    return rows.map(row => transformFromDbColumns(tableName, row, mappings));
+}
+export function hasColumnMapping(mappings) {
+    return mappings.size > 0;
+}

package/dist/esm/core/shared/errors.js

@@ -0,0 +1,13 @@
+import { RelqConfigError } from "../../../shared/errors/relq-errors.js";
+export class RelqDialectError extends RelqConfigError {
+    dialect;
+    suggestion;
+    constructor(message, dialect, suggestion) {
+        super(`${message}\n` +
+            `  Dialect: ${dialect}\n` +
+            (suggestion ? `  Suggestion: ${suggestion}` : ''));
+        this.name = 'RelqDialectError';
+        this.dialect = dialect;
+        this.suggestion = suggestion;
+    }
+}

package/dist/esm/core/shared/index.js

@@ -0,0 +1,6 @@
+export { RelqDialectError } from "./errors.js";
+export { buildColumnMappings, transformToDbColumns, transformFromDbColumns, transformResultsFromDb, hasColumnMapping } from "./column-mapping.js";
+export { validateData, validateComposite } from "./validation.js";
+export { deserializeRow as transformDeserializeRow, serializeRow as transformSerializeRow, buildColumnTypeMap } from "./transform.js";
+export { createTableAccessor } from "./table-accessor.js";
+export { registerInstance, unregisterInstance, activeInstances } from "./cleanup.js";

package/dist/esm/core/shared/table-accessor.js

@@ -0,0 +1,19 @@
+import { ConnectedQueryBuilder } from "../helpers/ConnectedQueryBuilder.js";
+export function createTableAccessor(relq, schema) {
+    const tableFunction = (tableName) => {
+        return new ConnectedQueryBuilder(tableName, relq);
+    };
+    return new Proxy(tableFunction, {
+        get(target, prop, receiver) {
+            if (prop in target) {
+                return Reflect.get(target, prop, receiver);
+            }
+            if (typeof prop === 'string' && schema && prop in schema) {
+                const tableDef = schema[prop];
+                const sqlTableName = tableDef?.$name || prop;
+                return new ConnectedQueryBuilder(sqlTableName, relq, prop);
+            }
+            return undefined;
+        }
+    });
+}

package/dist/esm/core/shared/transform.js

@@ -0,0 +1,30 @@
+export function deserializeRow(row, columnTypes, coercion) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        const dbType = columnTypes.get(key);
+        result[key] = dbType ? coercion.deserializeValue(value, dbType) : value;
+    }
+    return result;
+}
+export function serializeRow(row, columnTypes, coercion) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        const dbType = columnTypes.get(key);
+        result[key] = dbType ? coercion.serializeValue(value, dbType) : value;
+    }
+    return result;
+}
+export function buildColumnTypeMap(tableDef) {
+    const typeMap = new Map();
+    const columns = tableDef.$columns || tableDef;
+    for (const [key, colDef] of Object.entries(columns)) {
+        if (colDef && typeof colDef === 'object') {
+            const col = colDef;
+            const sqlType = col.$sqlType || (typeof col.$type === 'string' ? col.$type : undefined);
+            if (sqlType) {
+                typeMap.set(key, sqlType);
+            }
+        }
+    }
+    return typeMap;
+}

package/dist/esm/core/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/core/shared/validation.js

@@ -0,0 +1,136 @@
+import { RelqQueryError } from "../../../shared/errors/relq-errors.js";
+import { debugLog } from "../helpers/methods.js";
+export function validateData(tableName, data, operation, mappings, config) {
+    const validation = config?.validation;
+    if (validation?.enabled === false)
+        return;
+    const mapping = mappings.get(tableName);
+    if (!mapping) {
+        debugLog(config, `No mapping found for table: ${tableName}. Available:`, Array.from(mappings.keys()));
+        return;
+    }
+    const errors = [];
+    const validateLength = validation?.validateLength !== false;
+    const validateTypes = validation?.validateTypes !== false;
+    const onError = validation?.onError ?? 'throw';
+    debugLog(config, `Validating ${operation} on ${tableName}. Fields:`, Object.keys(data));
+    for (const [propName, value] of Object.entries(data)) {
+        if (value === null || value === undefined)
+            continue;
+        const colType = mapping.propToType.get(propName);
+        const colTypeStr = typeof colType === 'string' ? colType : null;
+        if (validateTypes && colTypeStr) {
+            const jsType = typeof value;
+            const upperType = colTypeStr.toUpperCase();
+            if (['INTEGER', 'INT', 'SMALLINT', 'BIGINT', 'INT2', 'INT4', 'INT8', 'SERIAL'].some(t => upperType.includes(t))) {
+                if (jsType !== 'number' && jsType !== 'bigint' && jsType !== 'string') {
+                    errors.push(`${propName}: expected number for ${colType}, got ${jsType}`);
+                }
+            }
+            else if (['REAL', 'DOUBLE', 'FLOAT', 'NUMERIC', 'DECIMAL'].some(t => upperType.includes(t))) {
+                if (jsType !== 'number' && jsType !== 'string') {
+                    errors.push(`${propName}: expected number for ${colType}, got ${jsType}`);
+                }
+            }
+            else if (upperType.includes('BOOL')) {
+                if (jsType !== 'boolean') {
+                    errors.push(`${propName}: expected boolean for ${colType}, got ${jsType}`);
+                }
+            }
+            else if (['VARCHAR', 'CHAR', 'TEXT', 'UUID'].some(t => upperType.includes(t))) {
+                if (jsType !== 'string') {
+                    errors.push(`${propName}: expected string for ${colType}, got ${jsType}`);
+                }
+            }
+        }
+        if (validateLength && typeof value === 'string' && colTypeStr) {
+            const lengthMatch = colTypeStr.match(/(?:var)?char\((\d+)\)/i);
+            if (lengthMatch) {
+                const maxLength = parseInt(lengthMatch[1], 10);
+                if (value.length > maxLength) {
+                    errors.push(`${propName}: string length ${value.length} exceeds ${colTypeStr} limit of ${maxLength}`);
+                }
+            }
+        }
+        const validateFn = mapping.propToValidate.get(propName);
+        if (validateFn) {
+            const isValid = validateFn(value);
+            debugLog(config, `Domain validation for '${propName}' with value '${value}': isValid=${isValid}`);
+            if (!isValid) {
+                errors.push(`${propName}: value '${value}' failed domain validation`);
+            }
+        }
+        const compositeFields = mapping.propToFields.get(propName);
+        if (compositeFields && value && typeof value === 'object') {
+            validateComposite(propName, value, compositeFields, errors, config);
+        }
+        const checkValues = mapping.propToCheckValues.get(propName);
+        if (checkValues && checkValues.length > 0 && typeof value === 'string') {
+            if (!checkValues.includes(value)) {
+                errors.push(`${propName}: value '${value}' not in allowed values [${checkValues.join(', ')}]`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        const message = `Validation failed for ${operation} on ${tableName}:\n  - ${errors.join('\n  - ')}`;
+        debugLog(config, message);
+        if (onError === 'throw') {
+            throw new RelqQueryError(message);
+        }
+        else if (onError === 'warn') {
+            console.warn('[Relq]', message);
+        }
+        else if (onError === 'log') {
+            console.log('[Relq]', message);
+        }
+    }
+}
+export function validateComposite(propName, value, fields, errors, config) {
+    const validation = config?.validation;
+    const validateLength = validation?.validateLength !== false;
+    const validateTypes = validation?.validateTypes !== false;
+    for (const [fieldName, colDef] of Object.entries(fields)) {
+        const colConfig = colDef;
+        const fieldValue = value[fieldName];
+        const colType = colConfig.$sqlType ?? colConfig.$config?.$type ?? (typeof colConfig.$type === 'string' ? colConfig.$type : 'TEXT');
+        const upperType = colType.toUpperCase();
+        const isNullable = colConfig.$config?.$nullable ?? colConfig.$nullable;
+        debugLog(config, `Composite field '${propName}.${fieldName}': value=${JSON.stringify(fieldValue)}, colType=${colType}, nullable=${isNullable}`);
+        if (fieldValue === null || fieldValue === undefined) {
+            if (isNullable === false) {
+                errors.push(`${propName}.${fieldName}: cannot be null`);
+            }
+            continue;
+        }
+        if (validateTypes && upperType) {
+            const jsType = typeof fieldValue;
+            if (['INTEGER', 'INT', 'SMALLINT', 'BIGINT', 'SERIAL'].some(t => upperType.includes(t))) {
+                if (jsType !== 'number' && jsType !== 'bigint' && jsType !== 'string') {
+                    errors.push(`${propName}.${fieldName}: expected number, got ${jsType}`);
+                }
+            }
+            else if (['VARCHAR', 'CHAR', 'TEXT'].some(t => upperType.includes(t))) {
+                if (jsType !== 'string') {
+                    errors.push(`${propName}.${fieldName}: expected string, got ${jsType}`);
+                }
+            }
+        }
+        if (validateLength && typeof fieldValue === 'string' && typeof colType === 'string') {
+            const lengthMatch = colType.match(/(?:var)?char\((\d+)\)/i);
+            if (lengthMatch) {
+                const maxLength = parseInt(lengthMatch[1], 10);
+                if (fieldValue.length > maxLength) {
+                    errors.push(`${propName}.${fieldName}: length ${fieldValue.length} exceeds ${maxLength}`);
+                }
+            }
+        }
+        if (colConfig.$validate && typeof colConfig.$validate === 'function') {
+            if (!colConfig.$validate(fieldValue)) {
+                errors.push(`${propName}.${fieldName}: failed domain validation`);
+            }
+        }
+        if (colConfig.$fields && fieldValue && typeof fieldValue === 'object') {
+            validateComposite(`${propName}.${fieldName}`, fieldValue, colConfig.$fields, errors, config);
+        }
+    }
+}

package/dist/esm/core/types/core.types.js

@@ -0,0 +1 @@
+export {};