Merge pull request #25 from jacksonkasi1/dev

fix(engine): preserve runtime extensions via non-enumerable symbol during config cloning

Author: jacksonkasi1

bun.lock

@@ -1,6 +1,6 @@
 {
   "name": "@tablecraft/engine",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "The backend query engine for TableCraft",
   "type": "module",
   "main": "dist/index.js",

packages/engine/package.json

@@ -67,6 +67,12 @@ import {
 	introspectTable,
 } from "./utils/introspect";
 
+export const TABLECRAFT_EXTENSIONS_KEY: unique symbol = Symbol.for("__tablecraft_ext") as any;
+
+export type TableConfigWithExtensions<T extends Table = Table> = TableConfig & {
+	[TABLECRAFT_EXTENSIONS_KEY]?: RuntimeExtensions<T>;
+};
+
 type InferColumns<T> = T extends { _: { columns: infer C } }
 	? keyof C & string
 	: string;
@@ -113,7 +119,7 @@ export interface RuntimeExtensions<T extends Table = Table> {
 	};
 }
 
-function emptyExtensions<T extends Table = Table>(): RuntimeExtensions<T> {
+export function emptyExtensions<T extends Table = Table>(): RuntimeExtensions<T> {
 	return {
 		computedExpressions: new Map(),
 		transforms: new Map(),
@@ -124,6 +130,25 @@ function emptyExtensions<T extends Table = Table>(): RuntimeExtensions<T> {
 		rawOrderBys: [],
 		ctes: new Map(),
 		sqlJoinConditions: new Map(),
+		countMode: undefined,
+	};
+}
+
+function cloneExtensions<T extends Table = Table>(
+	ext: RuntimeExtensions<T> = emptyExtensions<T>(),
+): RuntimeExtensions<T> {
+	return {
+		...ext,
+		computedExpressions: new Map(ext.computedExpressions),
+		transforms: new Map(ext.transforms),
+		rawSelects: new Map(ext.rawSelects),
+		rawWheres: [...ext.rawWheres],
+		dynamicWheres: [...ext.dynamicWheres],
+		rawJoins: [...ext.rawJoins],
+		rawOrderBys: [...ext.rawOrderBys],
+		ctes: new Map(ext.ctes),
+		sqlJoinConditions: new Map(ext.sqlJoinConditions),
+		hooks: ext.hooks ? { ...ext.hooks } : undefined,
 	};
 }
 
@@ -134,10 +159,12 @@ export class TableDefinitionBuilder<T extends Table = Table> {
 	_table: T;
 	_ext: RuntimeExtensions<T>;
 
-	constructor(table: T, config: TableConfig) {
+	constructor(table: T, config: TableConfigWithExtensions<T>) {
 		this._table = table;
 		this._config = config;
-		this._ext = emptyExtensions();
+		this._ext = cloneExtensions(
+			config[TABLECRAFT_EXTENSIONS_KEY] ?? emptyExtensions<T>(),
+		);
 	}
 
 	// ──── Column Format / Metadata ────
@@ -1049,19 +1076,29 @@ export class TableDefinitionBuilder<T extends Table = Table> {
 
 	// ──── Output ────
 
-	toConfig(): TableConfig {
-		return { ...this._config };
+	toConfig(): TableConfigWithExtensions<T> {
+		const config = { ...this._config } as TableConfigWithExtensions<T>;
+		Object.defineProperty(config, TABLECRAFT_EXTENSIONS_KEY, {
+			value: cloneExtensions(this._ext),
+			enumerable: true,
+			configurable: true,
+			writable: true,
+		});
+		return config;
 	}
 }
 
 // ── Main Entry ──
 
 export function defineTable<T extends Table>(
 	table: T,
-	options?: QuickOptions<T> | TableConfig,
+	options?: QuickOptions<T> | TableConfigWithExtensions<T>,
 ): TableDefinitionBuilder<T> {
 	if (options && "columns" in options && Array.isArray(options.columns)) {
-		return new TableDefinitionBuilder(table, options as TableConfig);
+		return new TableDefinitionBuilder(
+			table,
+			options as TableConfigWithExtensions<T>,
+		);
 	}
 
 	const config = introspectTable(table);

packages/engine/src/define.ts

@@ -31,7 +31,13 @@ import { FieldSelector } from './core/fieldSelector';
 import { detectDialect, supportsFeature, Dialect } from './core/dialect';
 import { formatResponse, applyJsTransforms } from './utils/responseFormatter';
 import { exportData } from './utils/export';
-import { TableDefinitionBuilder, RuntimeExtensions, drizzleOperators } from './define';
+import {
+  TableDefinitionBuilder,
+  RuntimeExtensions,
+  TABLECRAFT_EXTENSIONS_KEY,
+  drizzleOperators,
+  emptyExtensions,
+} from './define';
 import { TableCraftError, QueryError, DialectError } from './errors';
 import { applyRoleBasedVisibility } from './core/roleFilter';
 import { buildMetadata } from './core/metadataBuilder';
@@ -44,24 +50,25 @@ function resolveInput(input: ConfigInput): {
   config: TableConfig;
   ext: RuntimeExtensions<any>;
 } {
-  if (input && typeof input === 'object' && '_config' in input && '_ext' in input) {
+  if (!input) {
+    throw new TableCraftError('Invalid input: Table configuration is required', 'VALIDATION_ERROR');
+  }
+
+  if (typeof input === 'object' && '_config' in input && '_ext' in input) {
     const b = input as TableDefinitionBuilder<any>;
-    return { config: b.toConfig(), ext: b._ext as RuntimeExtensions<any> };
+    const cfg = b.toConfig();
+    return { config: cfg, ext: cfg[TABLECRAFT_EXTENSIONS_KEY] as RuntimeExtensions<any> };
   }
+
+  const plainConfig = input as TableConfig & {
+    [TABLECRAFT_EXTENSIONS_KEY]?: RuntimeExtensions<any>;
+  };
+
+  const embeddedExt = plainConfig?.[TABLECRAFT_EXTENSIONS_KEY];
+
   return {
-    config: input as TableConfig,
-    ext: {
-      computedExpressions: new Map(),
-      transforms: new Map(),
-      rawSelects: new Map(),
-      rawWheres: [],
-      dynamicWheres: [],
-      rawJoins: [],
-      rawOrderBys: [],
-      ctes: new Map(),
-      sqlJoinConditions: new Map(),
-      countMode: undefined,
-    },
+    config: plainConfig,
+    ext: embeddedExt ?? emptyExtensions(),
   };
 }
 

packages/engine/src/engine.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { defineTable } from '../src/define';
+import { defineTable, TABLECRAFT_EXTENSIONS_KEY } from '../src/define';
 import { sql } from 'drizzle-orm';
 import { pgTable, uuid, varchar, integer, timestamp } from 'drizzle-orm/pg-core';
 
@@ -102,4 +102,25 @@ describe('columnMeta', () => {
     expect((col as any).width).toBe(150); // added by .columnMeta()
     expect((col as any).minWidth).toBe(100);
   });
-});
+
+  it('should rehydrate runtime extensions from toConfig output', () => {
+    const beforeQuery = (params: any) => params;
+
+    const builder = defineTable(orders)
+      .computed('profit', sql`${orders.total} - ${orders.cost}`)
+      .transform('status', (value) => String(value).toUpperCase())
+      .beforeQuery(beforeQuery);
+
+    const config = builder.toConfig();
+    const runtimeExt = config[TABLECRAFT_EXTENSIONS_KEY]!;
+
+    const rebuilt = defineTable(orders, { ...config });
+
+    expect(rebuilt._ext.computedExpressions.has('profit')).toBe(true);
+    expect(rebuilt._ext.transforms.has('status')).toBe(true);
+    expect(rebuilt._ext.hooks?.beforeQuery).toBe(beforeQuery);
+
+    rebuilt.rawWhere(sql`1 = 1`);
+    expect(runtimeExt.rawWheres).toHaveLength(0);
+  });
+});