@relq/orm 0.1.3 → 0.1.4

package/dist/esm/mysql/utils/fk-resolver.js

@@ -0,0 +1,179 @@
+export class MysqlForeignKeyResolutionError extends Error {
+    fromTable;
+    toTable;
+    constructor(fromTable, toTable, message) {
+        super(message || `No foreign key relationship found between "${fromTable}" and "${toTable}"`);
+        this.fromTable = fromTable;
+        this.toTable = toTable;
+        this.name = 'MysqlForeignKeyResolutionError';
+    }
+}
+export function resolveMysqlForeignKey(schema, fromTableKey, toTableKey) {
+    const fromTableDef = schema[fromTableKey];
+    const toTableDef = schema[toTableKey];
+    if (!fromTableDef || !toTableDef) {
+        return null;
+    }
+    const fromTableName = fromTableDef.$name;
+    const toTableName = toTableDef.$name;
+    if (fromTableDef.$foreignKeys) {
+        for (const fk of fromTableDef.$foreignKeys) {
+            if (fk.references.table === toTableName || fk.references.table === toTableKey) {
+                if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                    return {
+                        fromTable: fromTableName,
+                        fromColumn: resolveColumnName(fromTableDef, fk.columns[0]),
+                        toTable: toTableName,
+                        toColumn: resolveColumnName(toTableDef, fk.references.columns[0]),
+                        direction: 'forward',
+                    };
+                }
+            }
+        }
+    }
+    if (toTableDef.$foreignKeys) {
+        const candidates = [];
+        for (const fk of toTableDef.$foreignKeys) {
+            if (fk.references.table === fromTableName || fk.references.table === fromTableKey) {
+                if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                    candidates.push(fk);
+                }
+            }
+        }
+        if (candidates.length > 0) {
+            let best = candidates[0];
+            if (candidates.length > 1) {
+                let bestScore = 0;
+                const columns = toTableDef.$columns || {};
+                for (const candidate of candidates) {
+                    const colName = candidate.columns[0];
+                    for (const [propKey, colDef] of Object.entries(columns)) {
+                        if (!colDef)
+                            continue;
+                        const sqlName = colDef.$columnName || colDef.$sqlName;
+                        if (sqlName !== colName && propKey !== colName)
+                            continue;
+                        let score = 0;
+                        if (colDef.$primaryKey === true)
+                            score = 2;
+                        else if (colDef.$nullable === false || colDef.$notNull === true)
+                            score = 1;
+                        if (score > bestScore) {
+                            bestScore = score;
+                            best = candidate;
+                        }
+                        break;
+                    }
+                }
+            }
+            return {
+                fromTable: fromTableName,
+                fromColumn: resolveColumnName(fromTableDef, best.references.columns[0]),
+                toTable: toTableName,
+                toColumn: resolveColumnName(toTableDef, best.columns[0]),
+                direction: 'reverse',
+            };
+        }
+    }
+    for (const [_key, tableDef] of Object.entries(schema)) {
+        if (tableDef === fromTableDef || tableDef === toTableDef)
+            continue;
+        if (!tableDef.$foreignKeys)
+            continue;
+        for (const fk of tableDef.$foreignKeys) {
+            if (fk.references.table === fromTableName || fk.references.table === fromTableKey) {
+                const otherFk = tableDef.$foreignKeys.find(f => f !== fk && (f.references.table === toTableName || f.references.table === toTableKey));
+                if (otherFk) {
+                    continue;
+                }
+            }
+        }
+    }
+    return null;
+}
+export function resolveMysqlForeignKeyOrThrow(schema, fromTableKey, toTableKey) {
+    const result = resolveMysqlForeignKey(schema, fromTableKey, toTableKey);
+    if (!result) {
+        const available = getAvailableMysqlRelations(schema, fromTableKey);
+        let message = `No foreign key relationship found between "${fromTableKey}" and "${toTableKey}".`;
+        if (available.length > 0) {
+            message += ` Available FK relations from "${fromTableKey}": ${available.join(', ')}.`;
+        }
+        else {
+            message += ` No foreign keys defined on "${fromTableKey}".`;
+        }
+        message += ' Use an explicit join condition instead.';
+        throw new MysqlForeignKeyResolutionError(fromTableKey, toTableKey, message);
+    }
+    return result;
+}
+export function getAvailableMysqlRelations(schema, tableKey) {
+    const tableDef = schema[tableKey];
+    if (!tableDef || !tableDef.$foreignKeys) {
+        return [];
+    }
+    return tableDef.$foreignKeys.map(fk => {
+        const cols = fk.columns.join(', ');
+        const refCols = fk.references.columns.join(', ');
+        return `(${cols}) → ${fk.references.table}(${refCols})`;
+    });
+}
+export function getAllMysqlForeignKeys(schema, tableKey) {
+    const tableDef = schema[tableKey];
+    if (!tableDef) {
+        return [];
+    }
+    const tableName = tableDef.$name;
+    const results = [];
+    if (tableDef.$foreignKeys) {
+        for (const fk of tableDef.$foreignKeys) {
+            const targetKey = findTableKeyByName(schema, fk.references.table);
+            const targetDef = targetKey ? schema[targetKey] : null;
+            if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                results.push({
+                    fromTable: tableName,
+                    fromColumn: resolveColumnName(tableDef, fk.columns[0]),
+                    toTable: fk.references.table,
+                    toColumn: targetDef
+                        ? resolveColumnName(targetDef, fk.references.columns[0])
+                        : fk.references.columns[0],
+                    direction: 'forward',
+                });
+            }
+        }
+    }
+    for (const [otherKey, otherDef] of Object.entries(schema)) {
+        if (otherKey === tableKey)
+            continue;
+        if (!otherDef.$foreignKeys)
+            continue;
+        for (const fk of otherDef.$foreignKeys) {
+            if (fk.references.table === tableName || fk.references.table === tableKey) {
+                if (fk.columns.length > 0 && fk.references.columns.length > 0) {
+                    results.push({
+                        fromTable: tableName,
+                        fromColumn: resolveColumnName(tableDef, fk.references.columns[0]),
+                        toTable: otherDef.$name,
+                        toColumn: resolveColumnName(otherDef, fk.columns[0]),
+                        direction: 'reverse',
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+function resolveColumnName(tableDef, columnKey) {
+    if (tableDef.$columns && tableDef.$columns[columnKey]) {
+        return tableDef.$columns[columnKey].$columnName || columnKey;
+    }
+    return columnKey;
+}
+function findTableKeyByName(schema, tableName) {
+    for (const [key, def] of Object.entries(schema)) {
+        if (def.$name === tableName || key === tableName) {
+            return key;
+        }
+    }
+    return null;
+}

package/dist/esm/mysql/utils/index.js

@@ -0,0 +1,2 @@
+export { resolveMysqlForeignKey, resolveMysqlForeignKeyOrThrow, getAvailableMysqlRelations, getAllMysqlForeignKeys, MysqlForeignKeyResolutionError, } from "./fk-resolver.js";
+export { deserializeMysqlValue, serializeMysqlValue, deserializeMysqlRow, deserializeMysqlRows, serializeMysqlRow, extractMysqlSchemaColumns, } from "./type-coercion.js";

package/dist/esm/mysql/utils/type-coercion.js

@@ -0,0 +1,150 @@
+const BIGINT_TYPES = new Set(['BIGINT', 'BIGINT UNSIGNED', 'SERIAL']);
+const DATE_TYPES = new Set(['DATE', 'DATETIME', 'TIMESTAMP']);
+const JSON_TYPES = new Set(['JSON']);
+const DECIMAL_TYPES = new Set(['DECIMAL', 'NUMERIC', 'DEC', 'FIXED']);
+export function deserializeMysqlValue(value, mysqlType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const upperType = mysqlType.toUpperCase();
+    if (BIGINT_TYPES.has(upperType) || upperType.startsWith('BIGINT')) {
+        if (typeof value === 'string') {
+            return BigInt(value);
+        }
+        if (typeof value === 'number') {
+            return BigInt(value);
+        }
+        return value;
+    }
+    if (DATE_TYPES.has(upperType) || upperType.startsWith('DATETIME') || upperType.startsWith('TIMESTAMP')) {
+        if (value instanceof Date) {
+            return value;
+        }
+        if (typeof value === 'string' || typeof value === 'number') {
+            return new Date(value);
+        }
+        return value;
+    }
+    if (JSON_TYPES.has(upperType)) {
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+        }
+        return value;
+    }
+    if (DECIMAL_TYPES.has(upperType) || upperType.startsWith('DECIMAL') || upperType.startsWith('NUMERIC')) {
+        if (typeof value === 'string') {
+            const num = Number(value);
+            return Number.isFinite(num) ? num : value;
+        }
+        return value;
+    }
+    if (upperType === 'TINYINT(1)' || upperType === 'TINYINT' || upperType === 'BOOL' || upperType === 'BOOLEAN') {
+        if (typeof value === 'number') {
+            return value !== 0;
+        }
+        if (Buffer.isBuffer(value)) {
+            return value[0] !== 0;
+        }
+        return Boolean(value);
+    }
+    if (upperType === 'BIT(1)' || upperType === 'BIT') {
+        if (Buffer.isBuffer(value)) {
+            return value[0] !== 0;
+        }
+        if (typeof value === 'number') {
+            return value !== 0;
+        }
+        return Boolean(value);
+    }
+    if (upperType === 'SET' || upperType.startsWith('SET(')) {
+        if (typeof value === 'string') {
+            return value === '' ? [] : value.split(',');
+        }
+        return value;
+    }
+    return value;
+}
+export function serializeMysqlValue(value, mysqlType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    const upperType = mysqlType.toUpperCase();
+    if (BIGINT_TYPES.has(upperType) || upperType.startsWith('BIGINT')) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        return value;
+    }
+    if (DATE_TYPES.has(upperType) || upperType.startsWith('DATETIME') || upperType.startsWith('TIMESTAMP')) {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return value;
+    }
+    if (JSON_TYPES.has(upperType)) {
+        if (typeof value === 'object' && value !== null) {
+            return JSON.stringify(value);
+        }
+        return value;
+    }
+    if (upperType === 'TINYINT(1)' || upperType === 'TINYINT' || upperType === 'BOOL' || upperType === 'BOOLEAN') {
+        if (typeof value === 'boolean') {
+            return value ? 1 : 0;
+        }
+        return value;
+    }
+    if (upperType === 'SET' || upperType.startsWith('SET(')) {
+        if (Array.isArray(value)) {
+            return value.join(',');
+        }
+        return value;
+    }
+    return value;
+}
+export function deserializeMysqlRow(row, schema) {
+    const result = {};
+    const columnMap = new Map();
+    for (const [key, config] of Object.entries(schema)) {
+        const dbColumnName = config.$columnName || key;
+        const sqlType = config.$sqlType || (typeof config.$type === 'string' ? config.$type : 'VARCHAR');
+        columnMap.set(dbColumnName, { key, type: sqlType });
+    }
+    for (const [dbColumn, value] of Object.entries(row)) {
+        const mapping = columnMap.get(dbColumn);
+        if (mapping) {
+            result[mapping.key] = deserializeMysqlValue(value, mapping.type);
+        }
+        else {
+            result[dbColumn] = value;
+        }
+    }
+    return result;
+}
+export function deserializeMysqlRows(rows, schema) {
+    return rows.map(row => deserializeMysqlRow(row, schema));
+}
+export function serializeMysqlRow(row, schema) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+        const config = schema[key];
+        if (config) {
+            const sqlType = config.$sqlType || (typeof config.$type === 'string' ? config.$type : 'VARCHAR');
+            result[key] = serializeMysqlValue(value, sqlType);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function extractMysqlSchemaColumns(tableDefinition) {
+    if (tableDefinition && tableDefinition.$columns) {
+        return tableDefinition.$columns;
+    }
+    return null;
+}

package/dist/esm/mysql/window/index.js

@@ -0,0 +1 @@
+export { MysqlWindowBuilder } from "./window-builder.js";

package/dist/esm/mysql/window/window-builder.js

@@ -0,0 +1,73 @@
+import mysqlFormat from "../clients/shared/mysql-format.js";
+export class MysqlWindowBuilder {
+    partitionColumns = [];
+    orderColumns = [];
+    frameStart;
+    frameEnd;
+    frameMode;
+    partitionBy(...columns) {
+        this.partitionColumns.push(...columns);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.orderColumns.push({ column, direction });
+        return this;
+    }
+    rows(start, end) {
+        this.frameMode = 'ROWS';
+        this.frameStart = typeof start === 'number' ? `${start} PRECEDING` : start;
+        this.frameEnd = end ? (typeof end === 'number' ? `${end} FOLLOWING` : end) : 'CURRENT ROW';
+        return this;
+    }
+    range(start, end) {
+        this.frameMode = 'RANGE';
+        this.frameStart = typeof start === 'number' ? `${start} PRECEDING` : start;
+        this.frameEnd = end ? (typeof end === 'number' ? `${end} FOLLOWING` : end) : 'CURRENT ROW';
+        return this;
+    }
+    groups(start, end) {
+        this.frameMode = 'GROUPS';
+        this.frameStart = typeof start === 'number' ? `${start} PRECEDING` : start;
+        this.frameEnd = end ? (typeof end === 'number' ? `${end} FOLLOWING` : end) : 'CURRENT ROW';
+        return this;
+    }
+    toString() {
+        const parts = [];
+        if (this.partitionColumns.length > 0) {
+            parts.push(`PARTITION BY ${this.partitionColumns.map(c => mysqlFormat.ident(c)).join(', ')}`);
+        }
+        if (this.orderColumns.length > 0) {
+            parts.push(`ORDER BY ${this.orderColumns.map(o => `${mysqlFormat.ident(o.column)} ${o.direction}`).join(', ')}`);
+        }
+        if (this.frameMode && this.frameStart) {
+            parts.push(`${this.frameMode} BETWEEN ${this.frameStart} AND ${this.frameEnd}`);
+        }
+        return parts.join(' ');
+    }
+    rowNumber() {
+        return `ROW_NUMBER() OVER (${this.toString()})`;
+    }
+    rank() {
+        return `RANK() OVER (${this.toString()})`;
+    }
+    denseRank() {
+        return `DENSE_RANK() OVER (${this.toString()})`;
+    }
+    lag(column, offset = 1, defaultValue) {
+        const def = defaultValue !== undefined ? `, ${mysqlFormat.literal(defaultValue)}` : '';
+        return `LAG(${mysqlFormat.ident(column)}, ${offset}${def}) OVER (${this.toString()})`;
+    }
+    lead(column, offset = 1, defaultValue) {
+        const def = defaultValue !== undefined ? `, ${mysqlFormat.literal(defaultValue)}` : '';
+        return `LEAD(${mysqlFormat.ident(column)}, ${offset}${def}) OVER (${this.toString()})`;
+    }
+    firstValue(column) {
+        return `FIRST_VALUE(${mysqlFormat.ident(column)}) OVER (${this.toString()})`;
+    }
+    lastValue(column) {
+        return `LAST_VALUE(${mysqlFormat.ident(column)}) OVER (${this.toString()})`;
+    }
+    nthValue(column, n) {
+        return `NTH_VALUE(${mysqlFormat.ident(column)}, ${n}) OVER (${this.toString()})`;
+    }
+}

package/dist/esm/pg/clients/alloydb-client/capabilities.js

@@ -0,0 +1,28 @@
+export const ALLOYDB_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/pg/clients/alloydb-client/index.js

@@ -0,0 +1,2 @@
+export { RelqAlloyDB } from "./relq-alloydb.js";
+export { ALLOYDB_CAPABILITIES } from "./capabilities.js";

package/dist/esm/{core/pg-family/pg-client/relq-postgres.js → pg/clients/alloydb-client/relq-alloydb.js}

@@ -1,14 +1,14 @@
-import { ListenerConnection } from "../../../pubsub/listener-connection.js";
+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;
+import { ALLOYDB_CAPABILITIES } from "./capabilities.js";
+export class RelqAlloyDB extends PgBase {
+    dialect = 'alloydb';
+    capabilities = ALLOYDB_CAPABILITIES;
     listener = null;
     constructor(schema, config = {}) {
-        validateEnvConfig('postgres', config);
-        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'postgres' });
+        validateEnvConfig('alloydb', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'alloydb' });
         super(schema, resolvedConfig);
     }
     async subscribe(channel, callback) {
@@ -19,7 +19,7 @@ export class RelqPostgres extends PgBase {
                 user: this.config.user,
                 password: this.config.password,
                 database: this.config.database,
-                connectionString: this.config.connectionString,
+                connectionString: this.config.url,
                 ssl: this.config.ssl
             });
             this.listener.on('error', (err) => this.emitter.emit('listenerError', err));

package/dist/esm/pg/clients/aurora-client/capabilities.js

@@ -0,0 +1,28 @@
+export const AURORA_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/pg/clients/aurora-client/index.js

@@ -0,0 +1,2 @@
+export { RelqAurora } from "./relq-aurora.js";
+export { AURORA_CAPABILITIES } from "./capabilities.js";

package/dist/esm/pg/clients/aurora-client/relq-aurora.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 { AURORA_CAPABILITIES } from "./capabilities.js";
+export class RelqAurora extends PgBase {
+    dialect = 'aurora';
+    capabilities = AURORA_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('aurora', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'aurora' });
+        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.url,
+                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();
+    }
+}

package/dist/esm/pg/clients/citus-client/capabilities.js

@@ -0,0 +1,28 @@
+export const CITUS_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/pg/clients/citus-client/index.js

@@ -0,0 +1,2 @@
+export { RelqCitus } from "./relq-citus.js";
+export { CITUS_CAPABILITIES } from "./capabilities.js";

package/dist/esm/pg/clients/citus-client/relq-citus.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 { CITUS_CAPABILITIES } from "./capabilities.js";
+export class RelqCitus extends PgBase {
+    dialect = 'citus';
+    capabilities = CITUS_CAPABILITIES;
+    listener = null;
+    constructor(schema, config = {}) {
+        validateEnvConfig('citus', config);
+        const resolvedConfig = mergeWithPgEnv({ ...config, dialect: 'citus' });
+        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.url,
+                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();
+    }
+}

package/dist/esm/pg/clients/neon-client/capabilities.js

@@ -0,0 +1,28 @@
+export const NEON_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/pg/clients/neon-client/index.js

@@ -0,0 +1,2 @@
+export { RelqNeon } from "./relq-neon.js";
+export { NEON_CAPABILITIES } from "./capabilities.js";