@relq/orm 0.1.0

package/dist/cjs/core/relq-base.cjs

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqBase = void 0;
+const node_events_1 = require("node:events");
+const relq_errors_1 = require("../shared/errors/relq-errors.cjs");
+const condition_collector_1 = require("../condition/condition-collector.cjs");
+const helpers_1 = require("./helpers/index.cjs");
+const scalar_select_builder_1 = require("../select/scalar-select-builder.cjs");
+const column_mapping_1 = require("./shared/column-mapping.cjs");
+const validation_1 = require("./shared/validation.cjs");
+const table_accessor_1 = require("./shared/table-accessor.cjs");
+const cleanup_1 = require("./shared/cleanup.cjs");
+class RelqBase {
+    config;
+    schema;
+    emitter = new node_events_1.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) => (0, helpers_1.debugLog)(config, ...args)
+                : undefined;
+            (0, column_mapping_1.buildColumnMappings)(schema, this.columnMappings, log);
+        }
+        (0, cleanup_1.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 (0, column_mapping_1.transformToDbColumns)(tableName, data, this.columnMappings);
+    }
+    _transformFromDbColumns(tableName, data) {
+        return (0, column_mapping_1.transformFromDbColumns)(tableName, data, this.columnMappings);
+    }
+    _transformResultsFromDb(tableName, rows) {
+        return (0, column_mapping_1.transformResultsFromDb)(tableName, rows, this.columnMappings);
+    }
+    _hasColumnMapping() {
+        return (0, column_mapping_1.hasColumnMapping)(this.columnMappings);
+    }
+    _validateData(tableName, data, operation) {
+        (0, validation_1.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 [helpers_1.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 relq_errors_1.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);
+                    (0, helpers_1.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 (0, table_accessor_1.createTableAccessor)(this, this.schema);
+    }
+    raw(query, ...params) {
+        return new helpers_1.ConnectedRawQueryBuilder(query, params, this);
+    }
+    async transaction(callback) {
+        const { executeTransaction } = await Promise.resolve().then(() => __importStar(require("./helpers/ConnectedTransactionBuilder.cjs")));
+        return executeTransaction(this, callback);
+    }
+    with(name, query) {
+        return new helpers_1.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[helpers_1.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 scalar_select_builder_1.ConnectedScalarSelectBuilder(scalars, schema, {
+            executeSelectOne: this[helpers_1.INTERNAL].executeSelect.bind(this),
+            hasColumnMapping: this._hasColumnMapping.bind(this),
+            transformToDbColumns: this._transformToDbColumns.bind(this)
+        });
+    }
+    where(_tableName) {
+        return new condition_collector_1.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;
+            (0, cleanup_1.unregisterInstance)(this);
+        }
+        catch (error) {
+            console.error('Error closing database connection:', error);
+            throw error;
+        }
+    }
+    get closed() {
+        return this._isClosed;
+    }
+}
+exports.RelqBase = RelqBase;
+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/cjs/core/relq-client.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqBase = exports.RelqCockroachDB = exports.RelqDsql = exports.RelqNile = exports.RelqPostgres = exports.Relq = void 0;
+const pg_client_1 = require("./pg-family/pg-client/index.cjs");
+const nile_client_1 = require("./pg-family/nile-client/index.cjs");
+const dsql_client_1 = require("./pg-family/dsql-client/index.cjs");
+const cockroachdb_client_1 = require("./pg-family/cockroachdb-client/index.cjs");
+const relq_errors_1 = require("../shared/errors/relq-errors.cjs");
+class RelqImpl {
+    constructor(schema, dialect, options) {
+        const opts = options ?? {};
+        switch (dialect) {
+            case 'postgres':
+                return new pg_client_1.RelqPostgres(schema, { ...opts, dialect: 'postgres' });
+            case 'nile':
+                return new nile_client_1.RelqNile(schema, { ...opts, dialect: 'nile' });
+            case 'cockroachdb':
+                return new cockroachdb_client_1.RelqCockroachDB(schema, { ...opts, dialect: 'cockroachdb' });
+            case 'awsdsql':
+                return new dsql_client_1.RelqDsql(schema, { ...opts, dialect: 'awsdsql' });
+            case 'sqlite':
+                throw new relq_errors_1.RelqConfigError(`Dialect "sqlite" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'turso':
+                throw new relq_errors_1.RelqConfigError(`Dialect "turso" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'mysql':
+                throw new relq_errors_1.RelqConfigError(`Dialect "mysql" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'mariadb':
+                throw new relq_errors_1.RelqConfigError(`Dialect "mariadb" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'planetscale':
+                throw new relq_errors_1.RelqConfigError(`Dialect "planetscale" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            case 'xata':
+                throw new relq_errors_1.RelqConfigError(`Dialect "xata" is not yet implemented. ` +
+                    `Currently supported: postgres, nile, cockroachdb, awsdsql`, { field: 'dialect', value: dialect });
+            default:
+                throw new relq_errors_1.RelqConfigError(`Unknown dialect: "${dialect}". ` +
+                    `Supported dialects: postgres, nile, cockroachdb, awsdsql, sqlite, turso, mysql, mariadb, planetscale, xata`, { field: 'dialect', value: dialect });
+        }
+    }
+}
+exports.Relq = RelqImpl;
+var pg_client_2 = require("./pg-family/pg-client/index.cjs");
+Object.defineProperty(exports, "RelqPostgres", { enumerable: true, get: function () { return pg_client_2.RelqPostgres; } });
+var nile_client_2 = require("./pg-family/nile-client/index.cjs");
+Object.defineProperty(exports, "RelqNile", { enumerable: true, get: function () { return nile_client_2.RelqNile; } });
+var dsql_client_2 = require("./pg-family/dsql-client/index.cjs");
+Object.defineProperty(exports, "RelqDsql", { enumerable: true, get: function () { return dsql_client_2.RelqDsql; } });
+var cockroachdb_client_2 = require("./pg-family/cockroachdb-client/index.cjs");
+Object.defineProperty(exports, "RelqCockroachDB", { enumerable: true, get: function () { return cockroachdb_client_2.RelqCockroachDB; } });
+var relq_base_1 = require("./relq-base.cjs");
+Object.defineProperty(exports, "RelqBase", { enumerable: true, get: function () { return relq_base_1.RelqBase; } });
+exports.default = exports.Relq;

package/dist/cjs/core/shared/cleanup.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeInstances = void 0;
+exports.registerGlobalCleanupHandlers = registerGlobalCleanupHandlers;
+exports.registerInstance = registerInstance;
+exports.unregisterInstance = unregisterInstance;
+const node_process_1 = __importDefault(require("node:process"));
+exports.activeInstances = new Set();
+let cleanupHandlersRegistered = false;
+function registerGlobalCleanupHandlers() {
+    if (cleanupHandlersRegistered)
+        return;
+    if (typeof node_process_1.default === 'undefined' || !node_process_1.default.on)
+        return;
+    try {
+        if (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers')
+            return;
+    }
+    catch { }
+    node_process_1.default.on('beforeExit', async () => {
+        if (exports.activeInstances.size === 0)
+            return;
+        await Promise.all(Array.from(exports.activeInstances).map(instance => instance.close().catch(err => console.error('Error closing database connection:', err))));
+    });
+    cleanupHandlersRegistered = true;
+}
+function registerInstance(instance) {
+    exports.activeInstances.add(instance);
+    registerGlobalCleanupHandlers();
+}
+function unregisterInstance(instance) {
+    exports.activeInstances.delete(instance);
+}

package/dist/cjs/core/shared/column-mapping.cjs

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildColumnMappings = buildColumnMappings;
+exports.transformToDbColumns = transformToDbColumns;
+exports.transformFromDbColumns = transformFromDbColumns;
+exports.transformResultsFromDb = transformResultsFromDb;
+exports.hasColumnMapping = hasColumnMapping;
+const type_coercion_1 = require("../../utils/type-coercion.cjs");
+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
+        });
+    }
+}
+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] = (0, type_coercion_1.serializeValue)(value, colType);
+        }
+        else {
+            result[dbColName] = value;
+        }
+    }
+    return result;
+}
+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] = (0, type_coercion_1.deserializeValue)(value, colType);
+        }
+        else {
+            result[propName] = value;
+        }
+    }
+    return result;
+}
+function transformResultsFromDb(tableName, rows, mappings) {
+    const mapping = mappings.get(tableName);
+    if (!mapping)
+        return rows;
+    return rows.map(row => transformFromDbColumns(tableName, row, mappings));
+}
+function hasColumnMapping(mappings) {
+    return mappings.size > 0;
+}

package/dist/cjs/core/shared/errors.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelqDialectError = void 0;
+const relq_errors_1 = require("../../../shared/errors/relq-errors.cjs");
+class RelqDialectError extends relq_errors_1.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;
+    }
+}
+exports.RelqDialectError = RelqDialectError;

package/dist/cjs/core/shared/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeInstances = exports.unregisterInstance = exports.registerInstance = exports.createTableAccessor = exports.buildColumnTypeMap = exports.transformSerializeRow = exports.transformDeserializeRow = exports.validateComposite = exports.validateData = exports.hasColumnMapping = exports.transformResultsFromDb = exports.transformFromDbColumns = exports.transformToDbColumns = exports.buildColumnMappings = exports.RelqDialectError = void 0;
+var errors_1 = require("./errors.cjs");
+Object.defineProperty(exports, "RelqDialectError", { enumerable: true, get: function () { return errors_1.RelqDialectError; } });
+var column_mapping_1 = require("./column-mapping.cjs");
+Object.defineProperty(exports, "buildColumnMappings", { enumerable: true, get: function () { return column_mapping_1.buildColumnMappings; } });
+Object.defineProperty(exports, "transformToDbColumns", { enumerable: true, get: function () { return column_mapping_1.transformToDbColumns; } });
+Object.defineProperty(exports, "transformFromDbColumns", { enumerable: true, get: function () { return column_mapping_1.transformFromDbColumns; } });
+Object.defineProperty(exports, "transformResultsFromDb", { enumerable: true, get: function () { return column_mapping_1.transformResultsFromDb; } });
+Object.defineProperty(exports, "hasColumnMapping", { enumerable: true, get: function () { return column_mapping_1.hasColumnMapping; } });
+var validation_1 = require("./validation.cjs");
+Object.defineProperty(exports, "validateData", { enumerable: true, get: function () { return validation_1.validateData; } });
+Object.defineProperty(exports, "validateComposite", { enumerable: true, get: function () { return validation_1.validateComposite; } });
+var transform_1 = require("./transform.cjs");
+Object.defineProperty(exports, "transformDeserializeRow", { enumerable: true, get: function () { return transform_1.deserializeRow; } });
+Object.defineProperty(exports, "transformSerializeRow", { enumerable: true, get: function () { return transform_1.serializeRow; } });
+Object.defineProperty(exports, "buildColumnTypeMap", { enumerable: true, get: function () { return transform_1.buildColumnTypeMap; } });
+var table_accessor_1 = require("./table-accessor.cjs");
+Object.defineProperty(exports, "createTableAccessor", { enumerable: true, get: function () { return table_accessor_1.createTableAccessor; } });
+var cleanup_1 = require("./cleanup.cjs");
+Object.defineProperty(exports, "registerInstance", { enumerable: true, get: function () { return cleanup_1.registerInstance; } });
+Object.defineProperty(exports, "unregisterInstance", { enumerable: true, get: function () { return cleanup_1.unregisterInstance; } });
+Object.defineProperty(exports, "activeInstances", { enumerable: true, get: function () { return cleanup_1.activeInstances; } });

package/dist/cjs/core/shared/table-accessor.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTableAccessor = createTableAccessor;
+const ConnectedQueryBuilder_1 = require("../helpers/ConnectedQueryBuilder.cjs");
+function createTableAccessor(relq, schema) {
+    const tableFunction = (tableName) => {
+        return new ConnectedQueryBuilder_1.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_1.ConnectedQueryBuilder(sqlTableName, relq, prop);
+            }
+            return undefined;
+        }
+    });
+}

package/dist/cjs/core/shared/transform.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeRow = deserializeRow;
+exports.serializeRow = serializeRow;
+exports.buildColumnTypeMap = buildColumnTypeMap;
+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;
+}
+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;
+}
+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/cjs/core/shared/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });