@relq/orm 0.1.0

package/dist/esm/core/helpers/select-pagination.js

@@ -0,0 +1,226 @@
+import Cursor from "../../addon/cursor.js";
+import { RelqConfigError, RelqQueryError } from "../../../shared/errors/relq-errors.js";
+import { randomLimit } from "../../types/pagination-types.js";
+import { INTERNAL } from "./methods.js";
+export async function executeCursorEach(ctx, callback, options = {}) {
+    const batchSize = options.batchSize ?? 100;
+    const sql = ctx.builder.toString();
+    const relqAny = ctx.relq;
+    if (relqAny.usePooling === false || (!relqAny.pool && relqAny.client)) {
+        throw new RelqConfigError('each() requires pooled connections', { field: 'pooling', value: 'false (must be true)' });
+    }
+    const { client, release } = await ctx.relq[INTERNAL].getClientForCursor();
+    let cursor = null;
+    try {
+        await client.query('BEGIN');
+        cursor = client.query(new Cursor(sql));
+        let rows;
+        let index = 0;
+        outer: do {
+            rows = await new Promise((resolve, reject) => {
+                cursor.read(batchSize, (err, result) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(result);
+                });
+            });
+            const internal = ctx.relq[INTERNAL];
+            const transformedRows = ctx.tableName && internal.hasColumnMapping()
+                ? internal.transformResultsFromDb(ctx.tableName, rows)
+                : rows;
+            for (const row of transformedRows) {
+                const result = await callback(row, index++);
+                if (result === false) {
+                    break outer;
+                }
+            }
+        } while (rows.length > 0);
+        await closeCursor(cursor);
+        cursor = null;
+        await client.query('COMMIT');
+    }
+    catch (error) {
+        if (cursor) {
+            try {
+                await closeCursor(cursor);
+            }
+            catch {
+            }
+        }
+        try {
+            await client.query('ROLLBACK');
+        }
+        catch {
+        }
+        throw error;
+    }
+    finally {
+        release();
+    }
+}
+export async function executePagination(ctx, options, recurse) {
+    if (!options.mode || !['paging', 'offset'].includes(options.mode)) {
+        throw new RelqQueryError('pagination() requires "mode" to be one of: \'paging\', \'offset\'', { hint: 'Set mode: "paging" or mode: "offset"' });
+    }
+    const orderByArr = options.orderBy
+        ? (Array.isArray(options.orderBy[0]) ? options.orderBy : [options.orderBy])
+        : [];
+    for (const [column, direction] of orderByArr) {
+        const dbColumn = ctx.relq[INTERNAL].hasColumnMapping()
+            ? Object.keys(ctx.relq[INTERNAL].transformToDbColumns(ctx.tableName, { [column]: true }))[0]
+            : column;
+        ctx.builder.orderBy(dbColumn, direction);
+    }
+    const isPaging = options.mode === 'paging';
+    const shouldCount = options.count ?? isPaging;
+    let total = 0;
+    if (shouldCount) {
+        const countSql = ctx.builder.toCountSQL();
+        const countResult = await ctx.relq[INTERNAL].executeCount(countSql);
+        total = countResult.count;
+    }
+    if (isPaging) {
+        return executePagingMode(ctx, options, total, recurse);
+    }
+    if (options.mode === 'offset') {
+        return executeOffsetMode(ctx, options, total, shouldCount, recurse);
+    }
+    throw new RelqQueryError('Invalid pagination mode');
+}
+async function executePagingMode(ctx, options, total, recurse) {
+    const { page, perPage } = options;
+    if (typeof page !== 'number' || isNaN(page) || page < 1) {
+        throw new RelqQueryError('pagination() paging mode requires "page" as a positive number (1-indexed)', { hint: 'page must be >= 1' });
+    }
+    if (typeof perPage !== 'number' || isNaN(perPage) || perPage < 1) {
+        throw new RelqQueryError('pagination() paging mode requires "perPage" as a positive number', { hint: 'perPage must be >= 1' });
+    }
+    const offset = (page - 1) * perPage;
+    ctx.builder.limit(perPage);
+    ctx.builder.offset(offset);
+    const sql = ctx.builder.toString();
+    const result = await ctx.relq[INTERNAL].executeSelect(sql, ctx.tableName);
+    const totalPages = Math.ceil(total / perPage);
+    const hasNext = page < totalPages;
+    const hasPrev = page > 1;
+    const pagination = {
+        page,
+        perPage,
+        total,
+        totalPages,
+    };
+    if (hasNext) {
+        pagination.hasNext = true;
+        pagination.nextPage = page + 1;
+        Object.defineProperty(pagination, 'loadNext', {
+            value: () => recurse({ ...options, page: page + 1 }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasNext = false;
+    }
+    if (hasPrev) {
+        pagination.hasPrev = true;
+        pagination.prevPage = page - 1;
+        Object.defineProperty(pagination, 'loadPrev', {
+            value: () => recurse({ ...options, page: page - 1 }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasPrev = false;
+    }
+    addInspectProperties(pagination, () => {
+        const visible = { page, perPage, total, totalPages, hasNext };
+        if (hasNext)
+            visible.nextPage = page + 1;
+        visible.hasPrev = hasPrev;
+        if (hasPrev)
+            visible.prevPage = page - 1;
+        return visible;
+    });
+    return { data: result.data, pagination };
+}
+async function executeOffsetMode(ctx, options, total, shouldCount, recurse) {
+    const { position, limit: limitOpt } = options;
+    if (typeof position !== 'number' || isNaN(position)) {
+        throw new RelqQueryError('pagination() offset mode requires "position" as a number', { hint: 'position must be >= 0' });
+    }
+    if (limitOpt === undefined || (typeof limitOpt !== 'number' && !Array.isArray(limitOpt))) {
+        throw new RelqQueryError('pagination() offset mode requires "limit" as a number or [min, max] array', { hint: 'Use limit: number or limit: [min, max]' });
+    }
+    const limit = Array.isArray(limitOpt) ? randomLimit(limitOpt) : limitOpt;
+    ctx.builder.limit(limit + 1);
+    ctx.builder.offset(position);
+    const sql = ctx.builder.toString();
+    const result = await ctx.relq[INTERNAL].executeSelect(sql, ctx.tableName);
+    const hasMore = result.data.length > limit;
+    const hasPrev = position > 0;
+    const data = hasMore ? result.data.slice(0, limit) : result.data;
+    const pagination = {
+        position,
+        limit,
+        ...(shouldCount && { total }),
+    };
+    if (hasMore) {
+        pagination.hasMore = true;
+        pagination.nextPos = position + limit;
+        Object.defineProperty(pagination, 'loadNext', {
+            value: () => recurse({ ...options, position: position + limit }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasMore = false;
+    }
+    if (hasPrev) {
+        pagination.hasPrev = true;
+        pagination.prevPos = Math.max(0, position - limit);
+        Object.defineProperty(pagination, 'loadPrev', {
+            value: () => recurse({ ...options, position: Math.max(0, position - limit) }),
+            enumerable: false,
+            configurable: false
+        });
+    }
+    else {
+        pagination.hasPrev = false;
+    }
+    addInspectProperties(pagination, () => {
+        const visible = { position, limit };
+        if (shouldCount)
+            visible.total = total;
+        visible.hasMore = hasMore;
+        if (hasMore)
+            visible.nextPos = position + limit;
+        visible.hasPrev = hasPrev;
+        if (hasPrev)
+            visible.prevPos = Math.max(0, position - limit);
+        return visible;
+    });
+    return { data, pagination };
+}
+function closeCursor(cursor) {
+    return new Promise((resolve, reject) => {
+        cursor.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+function addInspectProperties(obj, getVisibleProps) {
+    Object.defineProperty(obj, Symbol.for('nodejs.util.inspect.custom'), {
+        value: () => getVisibleProps(),
+        enumerable: false
+    });
+    Object.defineProperty(obj, 'toJSON', {
+        value: () => getVisibleProps(),
+        enumerable: false
+    });
+}

package/dist/esm/core/helpers/select-types.js

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

package/dist/esm/core/pg-family/cockroachdb-client/capabilities.js

@@ -0,0 +1,28 @@
+export const COCKROACHDB_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: false,
+    fullTextSearch: false,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/core/pg-family/cockroachdb-client/index.js

@@ -0,0 +1,2 @@
+export { RelqCockroachDB } from "./relq-cockroach.js";
+export { COCKROACHDB_CAPABILITIES } from "./capabilities.js";

package/dist/esm/core/pg-family/cockroachdb-client/relq-cockroach.js

@@ -0,0 +1,12 @@
+import { PgBase } from "../shared/pg-base.js";
+import { COCKROACHDB_CAPABILITIES } from "./capabilities.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+export class RelqCockroachDB extends PgBase {
+    dialect = 'cockroachdb';
+    capabilities = COCKROACHDB_CAPABILITIES;
+    constructor(schema, config = {}) {
+        validateEnvConfig('cockroachdb', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'cockroachdb' });
+        super(schema, resolvedConfig);
+    }
+}

package/dist/esm/core/pg-family/dsql-client/capabilities.js

@@ -0,0 +1,28 @@
+export const DSQL_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: false,
+    arrays: false,
+    ranges: false,
+    fullTextSearch: false,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: false,
+    triggers: false,
+    sequences: false,
+    copy: true,
+    vacuum: false,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/core/pg-family/dsql-client/index.js

@@ -0,0 +1,2 @@
+export { RelqDsql } from "./relq-dsql.js";
+export { DSQL_CAPABILITIES } from "./capabilities.js";

package/dist/esm/core/pg-family/dsql-client/relq-dsql.js

@@ -0,0 +1,12 @@
+import { PgBase } from "../shared/pg-base.js";
+import { DSQL_CAPABILITIES } from "./capabilities.js";
+import { mergeWithAwsEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+export class RelqDsql extends PgBase {
+    dialect = 'awsdsql';
+    capabilities = DSQL_CAPABILITIES;
+    constructor(schema, config = {}) {
+        validateEnvConfig('awsdsql', config);
+        const resolvedConfig = mergeWithAwsEnv({ ...config, dialect: 'awsdsql' });
+        super(schema, resolvedConfig);
+    }
+}

package/dist/esm/core/pg-family/index.js

@@ -0,0 +1,6 @@
+export { RelqPostgres, PG_CAPABILITIES } from "./pg-client/index.js";
+export { RelqNile, NILE_CAPABILITIES } from "./nile-client/index.js";
+export { RelqDsql, DSQL_CAPABILITIES } from "./dsql-client/index.js";
+export { RelqCockroachDB, COCKROACHDB_CAPABILITIES } from "./cockroachdb-client/index.js";
+export { PgBase } from "./shared/pg-base.js";
+export { pgDialect } from "./shared/pg-dialect.js";

package/dist/esm/core/pg-family/nile-client/capabilities.js

@@ -0,0 +1,28 @@
+export const NILE_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: false,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/core/pg-family/nile-client/index.js

@@ -0,0 +1,2 @@
+export { RelqNile } from "./relq-nile.js";
+export { NILE_CAPABILITIES } from "./capabilities.js";

package/dist/esm/core/pg-family/nile-client/relq-nile.js

@@ -0,0 +1,32 @@
+import { PgBase } from "../shared/pg-base.js";
+import { NILE_CAPABILITIES } from "./capabilities.js";
+import { TenantContext } from "./tenant-context.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+export class RelqNile extends PgBase {
+    dialect = 'nile';
+    capabilities = NILE_CAPABILITIES;
+    tenantCtx = new TenantContext();
+    constructor(schema, config = {}) {
+        validateEnvConfig('nile', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'nile' });
+        super(schema, resolvedConfig);
+    }
+    get queryFn() {
+        return async (sql) => { await this._executeQuery(sql); };
+    }
+    async setTenant(tenantId) {
+        await this.ensureInitialized();
+        await this.tenantCtx.setTenant(tenantId, this.queryFn);
+    }
+    async clearTenant() {
+        await this.ensureInitialized();
+        await this.tenantCtx.clearTenant(this.queryFn);
+    }
+    getTenantContext() {
+        return this.tenantCtx.getTenantId();
+    }
+    async withTenant(tenantId, callback) {
+        await this.ensureInitialized();
+        return this.tenantCtx.withTenant(tenantId, this.queryFn, callback);
+    }
+}

package/dist/esm/core/pg-family/nile-client/tenant-context.js

@@ -0,0 +1,40 @@
+import { RelqConfigError } from "../../../../shared/errors/relq-errors.js";
+function escapeTenantId(value) {
+    if (value.includes('\0')) {
+        throw new RelqConfigError('Tenant ID cannot contain null bytes', {
+            field: 'tenantId',
+            value: '<contains null byte>'
+        });
+    }
+    return value.replace(/'/g, "''");
+}
+export class TenantContext {
+    currentTenantId = null;
+    async setTenant(tenantId, queryFn) {
+        const escapedId = escapeTenantId(tenantId);
+        await queryFn(`SET nile.tenant_id = '${escapedId}'`);
+        this.currentTenantId = tenantId;
+    }
+    async clearTenant(queryFn) {
+        await queryFn('RESET nile.tenant_id');
+        this.currentTenantId = null;
+    }
+    getTenantId() {
+        return this.currentTenantId;
+    }
+    async withTenant(tenantId, queryFn, callback) {
+        const previousTenantId = this.currentTenantId;
+        try {
+            await this.setTenant(tenantId, queryFn);
+            return await callback();
+        }
+        finally {
+            if (previousTenantId) {
+                await this.setTenant(previousTenantId, queryFn);
+            }
+            else {
+                await this.clearTenant(queryFn);
+            }
+        }
+    }
+}

package/dist/esm/core/pg-family/pg-client/capabilities.js

@@ -0,0 +1,28 @@
+export const PG_CAPABILITIES = {
+    returning: true,
+    lateral: true,
+    distinctOn: true,
+    listenNotify: true,
+    pooling: true,
+    cursors: true,
+    jsonb: true,
+    arrays: true,
+    ranges: true,
+    fullTextSearch: true,
+    upsert: true,
+    forUpdateSkipLocked: true,
+    windowFunctions: true,
+    cte: true,
+    recursiveCte: true,
+    explainAnalyze: true,
+    savepoints: true,
+    createTableAs: true,
+    materializedViews: true,
+    storedProcedures: true,
+    triggers: true,
+    sequences: true,
+    copy: true,
+    vacuum: true,
+    identifierQuote: '"',
+    parameterStyle: 'dollar',
+};

package/dist/esm/core/pg-family/pg-client/index.js

@@ -0,0 +1,2 @@
+export { RelqPostgres } from "./relq-postgres.js";
+export { PG_CAPABILITIES } from "./capabilities.js";

package/dist/esm/core/pg-family/pg-client/relq-postgres.js

@@ -0,0 +1,39 @@
+import { ListenerConnection } from "../../../pubsub/listener-connection.js";
+import { mergeWithPgEnv, validateEnvConfig } from "../../../utils/env-resolver.js";
+import { PgBase } from "../shared/pg-base.js";
+import { PG_CAPABILITIES } from "./capabilities.js";
+export class RelqPostgres extends PgBase {
+    dialect = 'postgres';
+    capabilities = PG_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('postgres', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'postgres' });
+        super(schema, resolvedConfig);
+    }
+    async subscribe(channel, callback) {
+        if (!this.listener) {
+            this.listener = new ListenerConnection({
+                host: this.config.host,
+                port: this.config.port,
+                user: this.config.user,
+                password: this.config.password,
+                database: this.config.database,
+                connectionString: this.config.connectionString,
+                ssl: this.config.ssl
+            });
+            this.listener.on('error', (err) => this.emitter.emit('listenerError', err));
+            this.listener.on('connect', () => this.emitter.emit('listenerConnect'));
+        }
+        const sub = await this.listener.subscribe(channel);
+        sub.on('notification', callback);
+        return () => sub.close();
+    }
+    async _close() {
+        if (this.listener) {
+            await this.listener.close();
+            this.listener = null;
+        }
+        await super._close();
+    }
+}