@hozon/db 0.1.0 → 0.2.1

package/lib/db.d.ts

@@ -3,6 +3,7 @@ import { type Logger } from '@sozai/log';
 import { Kysely } from 'kysely';
 import { type Migration } from 'kysely/migration';
 export type MigrationContext = {
+    tablePrefix: string;
     kind: Adapter['kind'];
     types: ColumnTypes;
     functions: Functions;

package/lib/db.js

@@ -4,6 +4,7 @@ import { Migrator } from 'kysely/migration';
 import { withTransactionalDDL } from './dialect.js';
 import { HozonDBClosedError, InvalidTablePrefixError, SavepointOverlapError } from './errors.js';
 import { checkStore } from './preflight.js';
+import { TablePrefixPlugin } from './table-prefix.js';
 export class HozonDB {
     #tablePrefix;
     #closed = false;
@@ -13,6 +14,7 @@ export class HozonDB {
     #migrations = new Map();
     #adapter;
     #db;
+    #storeDB;
     #logger;
     #migrated = new Map();
     #storeAPIs = new Map();
@@ -30,6 +32,7 @@ export class HozonDB {
                 new ParseJSONResultsPlugin()
             ]
         });
+        this.#storeDB = this.#db.withPlugin(new TablePrefixPlugin(this.#tablePrefix));
         this.#logger = params.logger ?? getLogger([
             'hozon',
             'db'
@@ -60,7 +63,7 @@ export class HozonDB {
             if (store == null) {
                 throw new Error(`Store "${name}" is not registered`);
             }
-            this.#storeAPIs.set(name, store.createAPI(this.#db, this.#adapter));
+            this.#storeAPIs.set(name, store.createAPI(this.#storeDB, this.#adapter));
         }
         return this.#storeAPIs.get(name);
     }
@@ -92,7 +95,7 @@ export class HozonDB {
         let result;
         let savepointID = 0;
         try {
-            result = await this.#db.transaction().execute(async (trx)=>{
+            result = await this.#storeDB.transaction().execute(async (trx)=>{
                 const txKysely = trx;
                 const txStoreAPIs = new Map();
                 const createScopedProvider = (scopedCommitHooks, scopedRollbackHooks)=>{
@@ -208,11 +211,23 @@ export class HozonDB {
     #getMigrations(store) {
         let migrations = this.#migrations.get(store.name);
         if (migrations == null) {
-            migrations = typeof store.migrations === 'function' ? store.migrations({
+            const storeMigrations = typeof store.migrations === 'function' ? store.migrations({
+                tablePrefix: this.#tablePrefix,
                 kind: this.#adapter.kind,
                 types: this.#adapter.types,
                 functions: this.#adapter.functions
             }) : store.migrations;
+            const plugin = new TablePrefixPlugin(this.#tablePrefix);
+            migrations = Object.fromEntries(Object.entries(storeMigrations).map(([name, migration])=>{
+                const down = migration.down;
+                return [
+                    name,
+                    {
+                        up: (db)=>migration.up(db.withPlugin(plugin)),
+                        down: down && ((db)=>down.call(migration, db.withPlugin(plugin)))
+                    }
+                ];
+            }));
             this.#migrations.set(store.name, migrations);
         }
         return migrations;

package/lib/index.d.ts

@@ -1,5 +1,9 @@
+export type { ColumnType, Expression, Generated, Insertable, RawBuilder, Selectable, SelectQueryBuilder, Transaction, Updateable, } from 'kysely';
+export { Kysely, sql } from 'kysely';
+export type { Migration } from 'kysely/migration';
 export type { HozonDBParams, MigrationContext, StoreDefinition, StoreProvider } from './db.js';
 export { HozonDB } from './db.js';
 export { HozonDBClosedError, InvalidTablePrefixError, SavepointOverlapError, SchemaVersionError, } from './errors.js';
 export { chunk, withKeepSet } from './keep-set.js';
 export { withStoreTransaction } from './store-transaction.js';
+export { TablePrefixPlugin } from './table-prefix.js';

package/lib/index.js

@@ -1,4 +1,6 @@
+export { Kysely, sql } from 'kysely';
 export { HozonDB } from './db.js';
 export { HozonDBClosedError, InvalidTablePrefixError, SavepointOverlapError, SchemaVersionError } from './errors.js';
 export { chunk, withKeepSet } from './keep-set.js';
 export { withStoreTransaction } from './store-transaction.js';
+export { TablePrefixPlugin } from './table-prefix.js';

package/lib/table-prefix.d.ts

@@ -0,0 +1,7 @@
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs, QueryResult, RootOperationNode, UnknownRow } from 'kysely';
+export declare class TablePrefixPlugin implements KyselyPlugin {
+    #private;
+    constructor(prefix: string);
+    transformQuery({ node, queryId }: PluginTransformQueryArgs): RootOperationNode;
+    transformResult({ result }: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/lib/table-prefix.js

@@ -0,0 +1,247 @@
+import { AliasNode, IdentifierNode, JoinNode, ListNode, OperationNodeTransformer, SchemableIdentifierNode, TableNode, UsingNode } from 'kysely';
+// Kysely's root-node guard is internal; keep this list checked against its public root union.
+const ROOT_NODE_KINDS = {
+    AlterTableNode: true,
+    AlterTypeNode: true,
+    CreateIndexNode: true,
+    CreateSchemaNode: true,
+    CreateTableNode: true,
+    CreateTypeNode: true,
+    CreateViewNode: true,
+    DeleteQueryNode: true,
+    DropIndexNode: true,
+    DropSchemaNode: true,
+    DropTableNode: true,
+    DropTypeNode: true,
+    DropViewNode: true,
+    InsertQueryNode: true,
+    MergeQueryNode: true,
+    RawNode: true,
+    RefreshMaterializedViewNode: true,
+    SelectQueryNode: true,
+    UpdateQueryNode: true
+};
+function isRootOperationNode(node) {
+    return Object.hasOwn(ROOT_NODE_KINDS, node.kind);
+}
+class TablePrefixTransformer extends OperationNodeTransformer {
+    #prefix;
+    #tables = new Set();
+    #ctes = new Set();
+    #aliases = new Set();
+    #writeTargets = new Set();
+    #writeNames = new Set();
+    #prefixedIdentifiers = new WeakSet();
+    constructor(prefix){
+        super();
+        this.#prefix = prefix;
+    }
+    transformNodeImpl(node, queryId) {
+        if (!isRootOperationNode(node) || node.kind === 'RawNode' && this.nodeStack.length > 1) {
+            return super.transformNodeImpl(node, queryId);
+        }
+        return this.#transformScope(node, queryId);
+    }
+    #transformScope(node, queryId) {
+        const previousTables = this.#tables;
+        const previousCTEs = this.#ctes;
+        const previousAliases = this.#aliases;
+        const previousWriteTargets = this.#writeTargets;
+        const previousWriteNames = this.#writeNames;
+        this.#tables = new Set(previousTables);
+        this.#ctes = new Set(previousCTEs);
+        this.#aliases = new Set(previousAliases);
+        this.#writeTargets = new Set();
+        this.#writeNames = new Set(previousWriteNames);
+        try {
+            let withNode;
+            if ('with' in node && node.with) {
+                withNode = this.#transformWithScope(node.with, queryId);
+            }
+            this.#collectTables(node);
+            this.#collectWriteTargets(node);
+            const transformed = super.transformNodeImpl(withNode ? {
+                ...node,
+                with: undefined
+            } : node, queryId);
+            return withNode ? {
+                ...transformed,
+                with: withNode
+            } : transformed;
+        } finally{
+            // Nested queries inherit visible names without leaking them back into the outer query.
+            this.#tables = previousTables;
+            this.#ctes = previousCTEs;
+            this.#aliases = previousAliases;
+            this.#writeTargets = previousWriteTargets;
+            this.#writeNames = previousWriteNames;
+        }
+    }
+    transformTable(node, queryId) {
+        // Revisit plugged subqueries for correlated references, but keep their physical tables.
+        // Kysely transformers clone containers but retain immutable identifier leaves.
+        if (this.#prefixedIdentifiers.has(node.table.identifier)) return node;
+        const name = node.table.identifier.name;
+        if (this.#ctes.has(name) && !this.#writeTargets.has(node.table.identifier)) {
+            return super.transformTable(node, queryId);
+        }
+        return this.#prefixTable(node);
+    }
+    #prefixTable(node) {
+        if (node.table.schema !== undefined || this.#prefixedIdentifiers.has(node.table.identifier)) return node;
+        const name = node.table.identifier.name;
+        const transformed = TableNode.create(`${this.#prefix}_${name}`);
+        this.#prefixedIdentifiers.add(transformed.table.identifier);
+        return transformed;
+    }
+    transformReference(node, queryId) {
+        return {
+            ...node,
+            column: this.transformNode(node.column, queryId),
+            table: node.table && this.#tables.has(node.table.table.identifier.name) && !this.#aliases.has(node.table.table.identifier.name) ? this.#writeNames.has(node.table.table.identifier.name) ? this.#prefixTable(node.table) : this.transformNode(node.table, queryId) : node.table
+        };
+    }
+    transformSelectModifier(node, queryId) {
+        return {
+            ...super.transformSelectModifier({
+                ...node,
+                of: undefined
+            }, queryId),
+            of: node.of?.map((item)=>this.#transformTableReference(item, queryId))
+        };
+    }
+    transformAggregateFunction(node, queryId) {
+        return {
+            ...super.transformAggregateFunction({
+                ...node,
+                aggregated: []
+            }, queryId),
+            aggregated: this.#transformTableArgs(node.func, node.aggregated, queryId)
+        };
+    }
+    transformFunction(node, queryId) {
+        return {
+            ...super.transformFunction({
+                ...node,
+                arguments: []
+            }, queryId),
+            arguments: this.#transformTableArgs(node.func, node.arguments, queryId)
+        };
+    }
+    #transformTableArgs(func, args, queryId) {
+        return func === 'json_agg' || func === 'to_json' ? args.map((arg)=>this.#transformTableReference(arg, queryId)) : this.transformNodeList(args, queryId);
+    }
+    #transformTableReference(node, queryId) {
+        // Only direct table references can be aliases; raw sql.table() nodes still name physical tables.
+        return TableNode.is(node) && node.table.schema === undefined && this.#aliases.has(node.table.identifier.name) ? node : this.transformNode(node, queryId);
+    }
+    #collectTables(node) {
+        this.#collectRawTables(node);
+        if ('name' in node && node.name && SchemableIdentifierNode.is(node.name)) {
+            this.#tables.add(node.name.identifier.name);
+        }
+        if ('from' in node && node.from) {
+            for (const table of node.from.froms)this.#collectTableExpression(table);
+        }
+        if ('into' in node && node.into) this.#collectTableExpression(node.into);
+        if ('table' in node && node.table) this.#collectTableExpression(node.table);
+        if ('joins' in node && node.joins) {
+            for (const join of node.joins)this.#collectTableExpression(join.table);
+        }
+        if ('using' in node && node.using) {
+            this.#collectTableExpression(JoinNode.is(node.using) ? node.using.table : node.using);
+        }
+    }
+    #transformWithScope(node, queryId) {
+        // Nonrecursive definitions see preceding CTEs, not their own name or later names.
+        if (node.recursive) {
+            for (const expression of node.expressions){
+                this.#ctes.add(expression.name.table.table.identifier.name);
+            }
+        }
+        const expressions = [];
+        for (const expression of node.expressions){
+            expressions.push({
+                ...expression,
+                expression: expression.expression.kind === 'RawNode' ? Object.freeze(this.#transformScope(expression.expression, queryId)) : this.transformNode(expression.expression, queryId)
+            });
+            this.#ctes.add(expression.name.table.table.identifier.name);
+        }
+        return {
+            ...node,
+            expressions
+        };
+    }
+    #collectWriteTargets(node) {
+        const collect = (table)=>{
+            if (TableNode.is(table)) {
+                this.#writeTargets.add(table.table.identifier);
+                this.#writeNames.add(table.table.identifier.name);
+            } else if (AliasNode.is(table)) {
+                collect(table.node);
+            } else if (ListNode.is(table)) {
+                for (const item of table.items)collect(item);
+            }
+        };
+        if (node.kind === 'InsertQueryNode' || node.kind === 'MergeQueryNode') {
+            if (node.into) collect(node.into);
+        } else if (node.kind === 'UpdateQueryNode') {
+            if (node.table) collect(node.table);
+        } else if (node.kind === 'DeleteQueryNode') {
+            for (const table of node.from.froms)collect(table);
+        }
+    }
+    #collectRawTables(node) {
+        // Qualifiers are references, not declarations. Nested queries collect their own scope.
+        if (node.kind === 'ReferenceNode' || node.kind === 'WithNode') return;
+        if (node.kind === 'RawNode') {
+            for (const parameter of node.parameters){
+                if (AliasNode.is(parameter)) {
+                    if (!isRootOperationNode(parameter.node) || parameter.node.kind === 'RawNode') this.#collectRawTables(parameter.node);
+                    this.#collectTableExpression(parameter);
+                    continue;
+                }
+                this.#collectTableExpression(parameter);
+                if (!isRootOperationNode(parameter) || parameter.kind === 'RawNode') this.#collectRawTables(parameter);
+            }
+            return;
+        }
+        for (const value of Object.values(node)){
+            for (const child of Array.isArray(value) ? value : [
+                value
+            ]){
+                if (child && typeof child === 'object' && 'kind' in child) {
+                    const operation = child;
+                    if (!isRootOperationNode(operation) || operation.kind === 'RawNode') this.#collectRawTables(operation);
+                }
+            }
+        }
+    }
+    #collectTableExpression(node) {
+        if (TableNode.is(node)) {
+            this.#tables.add(node.table.identifier.name);
+            this.#aliases.delete(node.table.identifier.name);
+            // Local read bindings shadow enclosing write qualifiers in correlated subqueries.
+            this.#writeNames.delete(node.table.identifier.name);
+        } else if (AliasNode.is(node)) {
+            if (TableNode.is(node.node)) this.#tables.add(node.node.table.identifier.name);
+            if (IdentifierNode.is(node.alias)) this.#aliases.add(node.alias.name);
+        } else if (ListNode.is(node)) {
+            for (const table of node.items)this.#collectTableExpression(table);
+        } else if (UsingNode.is(node)) {
+            for (const table of node.tables)this.#collectTableExpression(table);
+        }
+    }
+}
+export class TablePrefixPlugin {
+    #transformer;
+    constructor(prefix){
+        this.#transformer = new TablePrefixTransformer(prefix);
+    }
+    transformQuery({ node, queryId }) {
+        return this.#transformer.transformNode(node, queryId);
+    }
+    async transformResult({ result }) {
+        return result;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hozon/db",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Database registry, migrations and transactions for Hozon",
   "repository": {
     "type": "git",