@an5/adapters 0.2.5 → 0.2.6

package/dist/base/metadata.d.ts

@@ -1,3 +1,9 @@
+export interface RelationDef {
+    modelName: string;
+    relationType: "many" | "one";
+    foreignKey: string;
+    localKey: string;
+}
 export interface ModelFieldMeta {
     name?: string;
     ts?: string;
@@ -8,7 +14,11 @@ export interface ModelFieldMeta {
 export interface AdapterMetadata {
     modelToTable?: Record<string, string>;
     modelFields?: Record<string, any>;
+    relationMap?: Record<string, Record<string, RelationDef>>;
 }
 export declare function setAdapterMetadata(metadata: AdapterMetadata): void;
 export declare function getModelToTable(): Record<string, string>;
 export declare function getFieldsForModel(modelName: string): any;
+export declare function getRelationMap(): Record<string, Record<string, RelationDef>>;
+export declare function getRelationsForModel(modelName: string): Record<string, RelationDef>;
+export declare function createAdapterProxy<T extends object>(targetObj: T, tableGetter: (modelName: string) => any): T;

package/dist/base/metadata.js

@@ -3,15 +3,122 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setAdapterMetadata = setAdapterMetadata;
 exports.getModelToTable = getModelToTable;
 exports.getFieldsForModel = getFieldsForModel;
+exports.getRelationMap = getRelationMap;
+exports.getRelationsForModel = getRelationsForModel;
+exports.createAdapterProxy = createAdapterProxy;
 let modelToTable = {};
 let modelFields = {};
+let relationMap = {};
+let autoLoaded = false;
+function loadMetadataFromConfig() {
+    // Auto-loading scans the filesystem at runtime, so it only applies in Node.
+    // Lazy requires keep Node builtins out of browser builds.
+    if (typeof process === 'undefined' || !process.cwd)
+        return null;
+    const path = require('path');
+    const fs = require('fs');
+    const rootDir = process.cwd();
+    const configNames = ['an5Orm.config.js', 'an5Orm.config.cjs', 'an5Orm.config.json'];
+    const candidatesDirs = [rootDir, path.resolve(rootDir, '..'), path.resolve(rootDir, '../..')];
+    for (const dir of candidatesDirs) {
+        for (const name of configNames) {
+            const configPath = path.join(dir, name);
+            if (fs.existsSync(configPath)) {
+                try {
+                    const config = name.endsWith('.json')
+                        ? JSON.parse(fs.readFileSync(configPath, 'utf8'))
+                        : require(configPath);
+                    const metaFile = config?.outputs?.typescript?.metadataFile;
+                    if (metaFile) {
+                        const resolvedPath = path.isAbsolute(metaFile) ? metaFile : path.resolve(dir, metaFile);
+                        const withoutExt = resolvedPath.replace(/\.(ts|js|cjs|mjs)$/, '');
+                        const extensions = ['', '.js', '.ts', '.cjs'];
+                        for (const ext of extensions) {
+                            const checkPath = withoutExt + ext;
+                            if (fs.existsSync(checkPath)) {
+                                try {
+                                    const m = require(withoutExt);
+                                    if (m && (m.modelToTable || m.relationMap || m.modelFields)) {
+                                        return m;
+                                    }
+                                }
+                                catch { }
+                            }
+                        }
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    return null;
+}
+function tryAutoLoadMetadata() {
+    if (autoLoaded || Object.keys(modelToTable).length > 0)
+        return;
+    autoLoaded = true;
+    const configMeta = loadMetadataFromConfig();
+    if (configMeta && (configMeta.modelToTable || configMeta.relationMap || configMeta.modelFields)) {
+        modelToTable = { ...(configMeta.modelToTable || {}) };
+        modelFields = { ...(configMeta.modelFields || {}) };
+        relationMap = { ...(configMeta.relationMap || {}) };
+    }
+}
 function setAdapterMetadata(metadata) {
     modelToTable = { ...(metadata.modelToTable || {}) };
     modelFields = { ...(metadata.modelFields || {}) };
+    relationMap = { ...(metadata.relationMap || {}) };
 }
 function getModelToTable() {
+    tryAutoLoadMetadata();
     return modelToTable;
 }
 function getFieldsForModel(modelName) {
+    tryAutoLoadMetadata();
     return modelFields[modelName] || {};
 }
+function getRelationMap() {
+    tryAutoLoadMetadata();
+    return relationMap;
+}
+function getRelationsForModel(modelName) {
+    tryAutoLoadMetadata();
+    return relationMap[modelName] || {};
+}
+// ─── Dynamic model proxy ─────────────────────────────────────────────────────
+// Shared by An5Adapter and An5SheetsAdapter: `db.user` / `db.User` /
+// `db.users` resolve case-insensitively through the registered metadata and
+// delegate to `table(modelName)`. Real members (`$`-prefixed helpers and
+// methods) always win over model names.
+function createAdapterProxy(targetObj, tableGetter) {
+    return new Proxy(targetObj, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'string') {
+                if (prop in target || prop.startsWith('_') || prop.startsWith('$') || typeof target[prop] === 'function') {
+                    const val = target[prop];
+                    return typeof val === 'function' ? val.bind(target) : val;
+                }
+                let modelName = prop;
+                const modelToTable = getModelToTable();
+                if (!modelToTable[prop]) {
+                    const lowerProp = prop.toLowerCase();
+                    for (const [mName, tName] of Object.entries(modelToTable)) {
+                        const lowerM = mName.toLowerCase();
+                        const lowerT = tName.toLowerCase();
+                        if (lowerM === lowerProp ||
+                            lowerT === lowerProp ||
+                            lowerM + 's' === lowerProp ||
+                            lowerM + 'es' === lowerProp ||
+                            lowerT + 's' === lowerProp ||
+                            lowerT + 'es' === lowerProp) {
+                            modelName = mName;
+                            break;
+                        }
+                    }
+                }
+                return tableGetter(modelName);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}

package/dist/base/sql.d.ts

@@ -1,4 +1,22 @@
 import type { Dialect } from './types';
+import type { RelationDef } from './metadata';
 export declare function quote(name: string, dialect: Dialect): string;
-export declare function parseWhere(modelName: string, where: any, params: Record<string, any>, dialect: Dialect, prefix?: string): string;
+/** Quote a full table reference (may already be quoted, and may contain schema parts). */
+export declare function quoteTable(name: string, dialect: Dialect): string;
+export interface WhereContext {
+    /** Relations of the current model keyed by relation name. */
+    relationMap?: Record<string, Record<string, RelationDef>>;
+    /** model name → table name for resolving related tables. */
+    modelToTable?: Record<string, string>;
+    /** Fully-qualified reference to the current (self) table, e.g. `[users]` or `[dbo].[users]`. */
+    selfRef?: string;
+    /** Column prefix to disambiguate inside a correlated subquery (e.g. `__r.`). Includes trailing dot. */
+    colPrefix?: string;
+}
+/**
+ * Build a WHERE clause. Supports scalar fields, operators and relation filters
+ * (`some`/`none`/`every` for to-many, `is`/`isNot` for to-one) via EXISTS
+ * subqueries when `ctx.relationMap` is provided.
+ */
+export declare function parseWhere(modelName: string, where: any, params: Record<string, any>, dialect: Dialect, prefix?: string, ctx?: WhereContext): string;
 export declare function buildOrderBy(orderBy: any, dialect: Dialect): string;

package/dist/base/sql.js

@@ -1,29 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.quote = quote;
+exports.quoteTable = quoteTable;
 exports.parseWhere = parseWhere;
 exports.buildOrderBy = buildOrderBy;
 // ─── Quoting ───────────────────────────────────────────────────────────────────────
+function stripWrapping(name, left, right) {
+    return name.startsWith(left) && name.endsWith(right) ? name.slice(left.length, -right.length) : name;
+}
 function quote(name, dialect) {
+    const raw = String(name);
     if (dialect === 'postgres') {
-        if (name.startsWith('[') && name.endsWith(']'))
-            return `"${name.slice(1, -1)}"`;
-        if (name.startsWith('"'))
-            return name;
-        return `"${name}"`;
+        const unwrapped = stripWrapping(stripWrapping(raw, '[', ']'), '"', '"');
+        return `"${unwrapped.replace(/"/g, '""')}"`;
     }
     if (dialect === 'mysql') {
-        if (name.startsWith('[') && name.endsWith(']'))
-            return `\`${name.slice(1, -1)}\``;
-        if (name.startsWith('`'))
-            return name;
-        return `\`${name}\``;
+        const unwrapped = stripWrapping(stripWrapping(raw, '[', ']'), '`', '`');
+        return `\`${unwrapped.replace(/`/g, '``')}\``;
     }
     // mssql / sqlite
-    return name.startsWith('[') ? name : `[${name}]`;
+    const unwrapped = stripWrapping(raw, '[', ']');
+    return `[${unwrapped.replace(/\]/g, ']]')}]`;
+}
+/** Quote a full table reference (may already be quoted, and may contain schema parts). */
+function quoteTable(name, dialect) {
+    const raw = String(name);
+    if (raw.startsWith('[') || raw.startsWith('"') || raw.startsWith('`'))
+        return raw;
+    if (raw.includes('.')) {
+        const open = dialect === 'mysql' ? '`' : dialect === 'postgres' ? '"' : '[';
+        const close = open === '[' ? ']' : open;
+        return raw.split('.').map(p => `${open}${p.replace(new RegExp(close.replace(/[[\]]/g, '\\$&'), 'g'), close.repeat(2))}${close}`).join('.');
+    }
+    return quote(raw, dialect);
+}
+function sanitizeParamName(name) {
+    const cleaned = String(name).replace(/[^A-Za-z0-9_]/g, '_');
+    return /^[A-Za-z]/.test(cleaned) ? cleaned : `p_${cleaned}`;
+}
+function normalizeSortDirection(dir) {
+    return typeof dir === 'string' && dir.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
 }
 // ─── Where clause builder ──────────────────────────────────────────────────────────
-function parseWhere(modelName, where, params, dialect, prefix = '') {
+const OPERATOR_KEYS = ['equals', 'in', 'notIn', 'contains', 'startsWith', 'endsWith', 'not', 'gte', 'lte', 'gt', 'lt'];
+function isOperatorValue(value) {
+    if (!value || typeof value !== 'object' || value instanceof Date)
+        return false;
+    return OPERATOR_KEYS.some(op => op in value);
+}
+function resolveTable(modelName, ctx) {
+    if (ctx?.modelToTable?.[modelName])
+        return ctx.modelToTable[modelName];
+    const camel = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+    if (ctx?.modelToTable?.[camel])
+        return ctx.modelToTable[camel];
+    const lower = modelName.toLowerCase();
+    if (ctx?.modelToTable?.[lower])
+        return ctx.modelToTable[lower];
+    return modelName;
+}
+/**
+ * Build a WHERE clause. Supports scalar fields, operators and relation filters
+ * (`some`/`none`/`every` for to-many, `is`/`isNot` for to-one) via EXISTS
+ * subqueries when `ctx.relationMap` is provided.
+ */
+function parseWhere(modelName, where, params, dialect, prefix = '', ctx) {
     if (!where)
         return '';
     const conditions = [];
@@ -32,29 +73,41 @@ function parseWhere(modelName, where, params, dialect, prefix = '') {
         if (key.includes('_') &&
             value && typeof value === 'object' &&
             !(value instanceof Date) &&
-            !value.in && !value.contains &&
-            !value.not && !value.gte &&
-            !value.lte && !value.gt && !value.lt) {
+            !isOperatorValue(value)) {
             Object.assign(cleanWhere, value);
         }
         else {
             cleanWhere[key] = value;
         }
     }
+    const relations = ctx?.relationMap?.[modelName] || {};
+    const colPrefix = ctx?.colPrefix || '';
     for (const [key, value] of Object.entries(cleanWhere)) {
         if (key === 'OR' && Array.isArray(value)) {
-            const sub = value.map((v, i) => parseWhere(modelName, v, params, dialect, `${prefix}or_${i}_`)).filter(Boolean);
+            const sub = value.map((v, i) => parseWhere(modelName, v, params, dialect, `${prefix}or_${i}_`, ctx)).filter(Boolean);
             if (sub.length > 0)
                 conditions.push(`(${sub.join(' OR ')})`);
         }
-        else if (key === 'AND' && Array.isArray(value)) {
-            const sub = value.map((v, i) => parseWhere(modelName, v, params, dialect, `${prefix}and_${i}_`)).filter(Boolean);
+        else if (key === 'AND') {
+            const items = Array.isArray(value) ? value : [value];
+            const sub = items.map((v, i) => parseWhere(modelName, v, params, dialect, `${prefix}and_${i}_`, ctx)).filter(Boolean);
             if (sub.length > 0)
                 conditions.push(`(${sub.join(' AND ')})`);
         }
+        else if (key === 'NOT') {
+            const items = Array.isArray(value) ? value : [value];
+            const sub = items.map((v, i) => parseWhere(modelName, v, params, dialect, `${prefix}not_${i}_`, ctx)).filter(Boolean);
+            if (sub.length > 0)
+                conditions.push(`NOT (${sub.join(' AND ')})`);
+        }
+        else if (relations[key] && value && typeof value === 'object') {
+            const clause = buildRelationClause(relations[key], value, modelName, params, dialect, prefix, ctx);
+            if (clause)
+                conditions.push(clause);
+        }
         else {
-            const pname = `${prefix}${key}`;
-            const col = quote(key, dialect);
+            const pname = sanitizeParamName(`${prefix}${key}`);
+            const col = `${colPrefix}${quote(key, dialect)}`;
             if (value === null) {
                 conditions.push(`${col} IS NULL`);
             }
@@ -64,6 +117,13 @@ function parseWhere(modelName, where, params, dialect, prefix = '') {
                     if (v.not === null) {
                         conditions.push(`${col} IS NOT NULL`);
                     }
+                    else if (v.not && typeof v.not === 'object' && !(v.not instanceof Date) && !Array.isArray(v.not)) {
+                        const nestedParams = {};
+                        const nestedSql = parseWhere(modelName, { [key]: v.not }, nestedParams, dialect, `${prefix}${key}_not_`, ctx);
+                        Object.assign(params, nestedParams);
+                        if (nestedSql)
+                            conditions.push(`NOT (${nestedSql})`);
+                    }
                     else {
                         const p = `${pname}_not`;
                         params[p] = v.not;
@@ -71,9 +131,14 @@ function parseWhere(modelName, where, params, dialect, prefix = '') {
                     }
                 }
                 if (v.equals !== undefined) {
-                    const p = `${pname}_eq`;
-                    params[p] = v.equals;
-                    conditions.push(`${col} = @${p}`);
+                    if (v.equals === null) {
+                        conditions.push(`${col} IS NULL`);
+                    }
+                    else {
+                        const p = `${pname}_eq`;
+                        params[p] = v.equals;
+                        conditions.push(`${col} = @${p}`);
+                    }
                 }
                 if (v.contains !== undefined) {
                     const p = `${pname}_co`;
@@ -119,6 +184,15 @@ function parseWhere(modelName, where, params, dialect, prefix = '') {
                         conditions.push('1=0');
                     }
                 }
+                if (v.notIn !== undefined) {
+                    if (Array.isArray(v.notIn) && v.notIn.length > 0) {
+                        const ps = v.notIn.map((x, i) => { const p = `${pname}_notin${i}`; params[p] = x; return `@${p}`; });
+                        conditions.push(`${col} NOT IN (${ps.join(', ')})`);
+                    }
+                    else {
+                        conditions.push('1=1');
+                    }
+                }
             }
             else {
                 params[pname] = value;
@@ -128,6 +202,60 @@ function parseWhere(modelName, where, params, dialect, prefix = '') {
     }
     return conditions.join(' AND ');
 }
+function buildRelationClause(relation, value, modelName, params, dialect, prefix, ctx) {
+    const isMany = relation.relationType === 'many';
+    const qname = `${prefix}rel_${sanitizeParamName(relation.modelName)}`;
+    const childAlias = `__r_${sanitizeParamName(relation.modelName)}${qname.length}`.replace(/[^A-Za-z0-9_]/g, '_');
+    const childTable = quoteTable(resolveTable(relation.modelName, ctx), dialect);
+    const fk = quote(relation.foreignKey, dialect);
+    const lk = quote(relation.localKey, dialect);
+    const selfRef = (ctx?.selfRef || quoteTable(modelName, dialect)) + `.`;
+    // Correlation between the parent row and the related row.
+    const correlation = `${childAlias}.${fk} = ${selfRef}${lk}`;
+    // Correlated subquery for "there exists a related row matching <innerWhere>".
+    const buildExists = (innerWhere) => {
+        const inner = innerWhere ? ` AND (${innerWhere})` : '';
+        return `EXISTS (SELECT 1 FROM ${childTable} AS ${childAlias} WHERE ${correlation}${inner})`;
+    };
+    const parts = [];
+    if (isMany) {
+        if (value.some !== undefined) {
+            const inner = buildInnerWhere(relation.modelName, value.some === null ? {} : value.some, params, dialect, prefix, ctx, childAlias);
+            parts.push(buildExists(inner));
+        }
+        if (value.none !== undefined) {
+            const inner = buildInnerWhere(relation.modelName, value.none === null ? {} : value.none, params, dialect, prefix, ctx, childAlias);
+            parts.push(`NOT ${buildExists(inner)}`);
+        }
+        if (value.every !== undefined) {
+            // "every" = no related row violates the condition.
+            const inner = buildInnerWhere(relation.modelName, value.every === null ? {} : value.every, params, dialect, prefix, ctx, childAlias);
+            const negated = inner ? `NOT (${inner})` : '';
+            const violated = `EXISTS (SELECT 1 FROM ${childTable} AS ${childAlias} WHERE ${correlation}${negated ? ` AND ${negated}` : ' AND 1=0'})`;
+            parts.push(`NOT ${violated}`);
+        }
+    }
+    else {
+        if (value.is !== undefined) {
+            const inner = buildInnerWhere(relation.modelName, value.is === null ? {} : value.is, params, dialect, prefix, ctx, childAlias);
+            parts.push(buildExists(inner));
+        }
+        if (value.isNot !== undefined) {
+            const inner = buildInnerWhere(relation.modelName, value.isNot === null ? {} : value.isNot, params, dialect, prefix, ctx, childAlias);
+            parts.push(`NOT ${buildExists(inner)}`);
+        }
+    }
+    return parts.length > 0 ? parts.join(' AND ') : null;
+}
+function buildInnerWhere(relModel, where, params, dialect, prefix, ctx, childAlias) {
+    const subCtx = {
+        ...(ctx?.relationMap !== undefined ? { relationMap: ctx.relationMap } : {}),
+        ...(ctx?.modelToTable !== undefined ? { modelToTable: ctx.modelToTable } : {}),
+        selfRef: childAlias || quoteTable(resolveTable(relModel, ctx), dialect),
+        colPrefix: childAlias ? `${childAlias}.` : '',
+    };
+    return parseWhere(relModel, where, params, dialect, `${prefix}rel_inner_`, subCtx);
+}
 // ─── Order by builder ──────────────────────────────────────────────────────────────
 function buildOrderBy(orderBy, dialect) {
     if (!orderBy)
@@ -136,7 +264,7 @@ function buildOrderBy(orderBy, dialect) {
     const parts = [];
     for (const entry of entries) {
         for (const [key, dir] of Object.entries(entry)) {
-            parts.push(`${quote(key, dialect)} ${dir.toUpperCase()}`);
+            parts.push(`${quote(key, dialect)} ${normalizeSortDirection(dir)}`);
         }
     }
     return parts.length > 0 ? `ORDER BY ${parts.join(', ')}` : '';

package/dist/base/types.d.ts

@@ -1,6 +1,9 @@
 export type Dialect = 'mssql' | 'postgres' | 'mysql' | 'sqlite' | 'googlesheets';
 export interface An5AdapterConfig {
-    connectionString: string;
+    connectionString?: string;
+    engine?: QueryEngine;
+    db?: any;
+    driver?: any;
     poolMax?: number;
     requestTimeout?: number;
     connectionTimeout?: number;

package/dist/browser.d.ts

@@ -1,5 +1,8 @@
 export { An5SheetsAdapter, SheetsTableClient, createAn5SheetsAdapter, parseSheetsConnectionString } from './googlesheets';
 export type { An5SheetsAdapterConfig } from './googlesheets';
-export type { An5AdapterConfig, Dialect } from './base/types';
+export { SqliteBrowserEngine, createBrowserSqliteAdapter } from './sqlite/browserEngine';
+export type { SqliteDriver, SqliteBrowserConfig } from './sqlite/browserEngine';
+export { An5Adapter, createAn5Adapter, createAdapter } from './an5Adapter';
+export type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from './base/types';
 export { getFieldsForModel, getModelToTable, setAdapterMetadata } from './base/metadata';
 export type { AdapterMetadata } from './base/metadata';

package/dist/browser.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setAdapterMetadata = exports.getModelToTable = exports.getFieldsForModel = exports.parseSheetsConnectionString = exports.createAn5SheetsAdapter = exports.SheetsTableClient = exports.An5SheetsAdapter = void 0;
-// Browser-safe entry — no SQL engine imports
+exports.setAdapterMetadata = exports.getModelToTable = exports.getFieldsForModel = exports.createAdapter = exports.createAn5Adapter = exports.An5Adapter = exports.createBrowserSqliteAdapter = exports.SqliteBrowserEngine = exports.parseSheetsConnectionString = exports.createAn5SheetsAdapter = exports.SheetsTableClient = exports.An5SheetsAdapter = void 0;
+// Browser-safe entry — supports in-browser SQLite (sql.js / WASM / custom driver) and Google Sheets
 var googlesheets_1 = require("./googlesheets");
 Object.defineProperty(exports, "An5SheetsAdapter", { enumerable: true, get: function () { return googlesheets_1.An5SheetsAdapter; } });
 Object.defineProperty(exports, "SheetsTableClient", { enumerable: true, get: function () { return googlesheets_1.SheetsTableClient; } });
 Object.defineProperty(exports, "createAn5SheetsAdapter", { enumerable: true, get: function () { return googlesheets_1.createAn5SheetsAdapter; } });
 Object.defineProperty(exports, "parseSheetsConnectionString", { enumerable: true, get: function () { return googlesheets_1.parseSheetsConnectionString; } });
+var browserEngine_1 = require("./sqlite/browserEngine");
+Object.defineProperty(exports, "SqliteBrowserEngine", { enumerable: true, get: function () { return browserEngine_1.SqliteBrowserEngine; } });
+Object.defineProperty(exports, "createBrowserSqliteAdapter", { enumerable: true, get: function () { return browserEngine_1.createBrowserSqliteAdapter; } });
+var an5Adapter_1 = require("./an5Adapter");
+Object.defineProperty(exports, "An5Adapter", { enumerable: true, get: function () { return an5Adapter_1.An5Adapter; } });
+Object.defineProperty(exports, "createAn5Adapter", { enumerable: true, get: function () { return an5Adapter_1.createAn5Adapter; } });
+Object.defineProperty(exports, "createAdapter", { enumerable: true, get: function () { return an5Adapter_1.createAdapter; } });
 var metadata_1 = require("./base/metadata");
 Object.defineProperty(exports, "getFieldsForModel", { enumerable: true, get: function () { return metadata_1.getFieldsForModel; } });
 Object.defineProperty(exports, "getModelToTable", { enumerable: true, get: function () { return metadata_1.getModelToTable; } });

package/dist/googlesheets/adapter.d.ts

@@ -2,6 +2,7 @@ import { An5SheetsAdapterConfig, resolveConfig } from './config';
 import { SheetsTableClient } from './tableClient';
 import { SheetMeta } from './types';
 export declare class An5SheetsAdapter {
+    [key: string]: any;
     private sheets;
     private fetchApi;
     config: ReturnType<typeof resolveConfig>;

package/dist/googlesheets/adapter.js

@@ -6,6 +6,7 @@ const config_1 = require("./config");
 const sqlExecutor_1 = require("./sqlExecutor");
 const tableClient_1 = require("./tableClient");
 const retry_1 = require("./retry");
+const metadata_1 = require("../base/metadata");
 // ─── Fetch-based API proxy for OAuth Access Token / API Key (browser-compatible) ──
 function createFetchApi(spreadsheetId, accessToken, apiKey) {
     const base = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}`;
@@ -79,6 +80,8 @@ class An5SheetsAdapter {
         this.fetchApi = null;
         this.sheetsCache = null;
         this.config = (0, config_1.resolveConfig)(config);
+        // Dynamic model access (`db.user` / `db.User`), same as An5Adapter.
+        return (0, metadata_1.createAdapterProxy)(this, (name) => this.table(name));
     }
     get isFetchMode() {
         return !!this.config.accessToken || !!this.config.apiKey;
@@ -96,9 +99,13 @@ class An5SheetsAdapter {
         }
         if (!this.sheets) {
             const { google } = await import('googleapis');
+            const { clientEmail, privateKey } = this.config;
+            if (!clientEmail || !privateKey) {
+                throw new Error('Google Sheets JWT auth requires clientEmail and privateKey (or use accessToken/apiKey fetch mode).');
+            }
             const auth = new google.auth.JWT({
-                email: this.config.clientEmail,
-                key: this.config.privateKey,
+                email: clientEmail,
+                key: privateKey,
                 scopes: ['https://www.googleapis.com/auth/spreadsheets'],
             });
             this.sheets = google.sheets({ version: 'v4', auth });

package/dist/googlesheets/config.d.ts

@@ -20,13 +20,13 @@ export declare function resolveConfig(config: An5SheetsAdapterConfig): {
     accessToken: string | undefined;
     apiKey: string | undefined;
     sheetMapping: Record<string, string> | undefined;
-    clientEmail?: undefined;
-    privateKey?: undefined;
+    clientEmail?: never;
+    privateKey?: never;
 } | {
+    accessToken?: never;
+    apiKey?: never;
     spreadsheetId: string;
     clientEmail: string;
     privateKey: string;
     sheetMapping: Record<string, string> | undefined;
-    accessToken?: undefined;
-    apiKey?: undefined;
 };

package/dist/googlesheets/helpers.js

@@ -126,6 +126,8 @@ function sortRows(rows, orderBy) {
     return [...rows].sort((a, b) => {
         for (const clause of clauses) {
             const [field, dir] = clause.split(/\s+/);
+            if (field === undefined)
+                continue;
             const direction = dir?.toUpperCase() === 'DESC' ? -1 : 1;
             const aVal = a[field];
             const bVal = b[field];

package/dist/googlesheets/parseConnectionString.js

@@ -13,10 +13,13 @@ exports.parseSheetsConnectionString = parseSheetsConnectionString;
 function parseSheetsConnectionString(url) {
     const clean = url.replace(/^googlesheets:\/\//, '');
     const parts = clean.split(';');
-    const spreadsheetId = parts[0].trim();
+    const spreadsheetId = (parts[0] ?? '').trim();
     const config = {};
     for (let i = 1; i < parts.length; i++) {
-        const part = parts[i].trim();
+        const rawPart = parts[i];
+        if (rawPart === undefined)
+            continue;
+        const part = rawPart.trim();
         if (!part)
             continue;
         const eqIdx = part.indexOf('=');