bunsane 0.3.2 → 0.5.0

package/database/instrumentedDb.ts

@@ -1,141 +1,141 @@
-import type { SQL } from "bun";
-import { logger as MainLogger } from "../core/Logger";
-import { runWithSignal } from "./cancellable";
-
-const logger = MainLogger.child({ scope: "db" });
-
-const SLOW_MS = parseInt(process.env.BUNSANE_DB_SLOW_MS ?? '500', 10);
-
-export type DataLoaderKind = 'entity' | 'component' | 'relation';
-
-interface DbStatsInternal {
-    totalCount: number;
-    totalMs: number;
-    maxMs: number;
-    slowCount: number;
-    abortedCount: number;
-    inFlight: number;
-    inFlightMax: number;
-    dataLoaderCalls: { entity: number; component: number; relation: number };
-}
-
-const stats: DbStatsInternal = {
-    totalCount: 0,
-    totalMs: 0,
-    maxMs: 0,
-    slowCount: 0,
-    abortedCount: 0,
-    inFlight: 0,
-    inFlightMax: 0,
-    dataLoaderCalls: { entity: 0, component: 0, relation: 0 },
-};
-
-/**
- * Per-request counter incremented when current request context is reachable
- * via the (request as any).__bunsaneStats pointer. We accept that as a
- * parameter from the call site so this module stays free of GraphQL imports.
- */
-export interface PerRequestCounters {
-    dbQueryCount: number;
-}
-
-/**
- * Execute `db.unsafe(sql, params)` with optional AbortSignal cancellation
- * and roundtrip telemetry. On abort the in-flight query is cancelled via
- * `Query.cancel()`. Total ms is recorded into module-level stats; calls
- * over `BUNSANE_DB_SLOW_MS` increment slowCount and emit a warn log.
- */
-export async function timedUnsafe<T = any>(
-    db: SQL,
-    sql: string,
-    params: any[],
-    signal?: AbortSignal,
-    perRequest?: PerRequestCounters,
-): Promise<T> {
-    const t0 = performance.now();
-    stats.inFlight++;
-    if (stats.inFlight > stats.inFlightMax) stats.inFlightMax = stats.inFlight;
-    if (perRequest) perRequest.dbQueryCount++;
-    let aborted = false;
-    try {
-        const q = (db as any).unsafe(sql, params);
-        return await runWithSignal<T>(q, signal);
-    } catch (err) {
-        if ((err as Error)?.name === 'AbortError' || signal?.aborted) {
-            aborted = true;
-            stats.abortedCount++;
-        }
-        throw err;
-    } finally {
-        const dt = performance.now() - t0;
-        stats.inFlight--;
-        stats.totalCount++;
-        stats.totalMs += dt;
-        if (dt > stats.maxMs) stats.maxMs = dt;
-        if (SLOW_MS > 0 && dt > SLOW_MS && !aborted) {
-            stats.slowCount++;
-            logger.warn(
-                {
-                    durationMs: Math.round(dt),
-                    thresholdMs: SLOW_MS,
-                    sqlSnippet: sql.length > 200 ? sql.slice(0, 200) + '…' : sql,
-                    msg: 'Slow DB call',
-                },
-                'Slow DB call',
-            );
-        }
-    }
-}
-
-/**
- * Increment the per-kind DataLoader counter. Called from inside DataLoader
- * batch functions so /metrics + access log can attribute load patterns.
- *
- * `perRequest` is loosely typed because RequestContext's `RequestStats`
- * (defined in core/RequestContext.ts) extends `PerRequestCounters` with
- * extra fields like `dataLoaderCalls`. We accept either shape here without
- * importing the higher-level type (which would create a cycle).
- */
-export function incrementDataLoaderCall(
-    kind: DataLoaderKind,
-    perRequest?: PerRequestCounters | { dataLoaderCalls?: { entity: number; component: number; relation: number } },
-): void {
-    stats.dataLoaderCalls[kind]++;
-    const dlc = (perRequest as any)?.dataLoaderCalls;
-    if (dlc) dlc[kind]++;
-}
-
-/**
- * Snapshot of accumulated DB stats for the /metrics endpoint.
- */
-export function getDbStats() {
-    const avgMs = stats.totalCount > 0 ? stats.totalMs / stats.totalCount : 0;
-    return {
-        totalCount: stats.totalCount,
-        totalMs: Math.round(stats.totalMs),
-        maxMs: Math.round(stats.maxMs),
-        avgMs: Number(avgMs.toFixed(2)),
-        slowCount: stats.slowCount,
-        abortedCount: stats.abortedCount,
-        inFlight: stats.inFlight,
-        inFlightMax: stats.inFlightMax,
-        slowThresholdMs: SLOW_MS,
-        dataLoaderCalls: { ...stats.dataLoaderCalls },
-    };
-}
-
-/**
- * Reset counters. Intended for tests only.
- */
-export function resetDbStats(): void {
-    stats.totalCount = 0;
-    stats.totalMs = 0;
-    stats.maxMs = 0;
-    stats.slowCount = 0;
-    stats.abortedCount = 0;
-    stats.inFlight = 0;
-    stats.inFlightMax = 0;
-    stats.dataLoaderCalls.entity = 0;
-    stats.dataLoaderCalls.component = 0;
-    stats.dataLoaderCalls.relation = 0;
-}
+import type { SQL } from "bun";
+import { logger as MainLogger } from "../core/Logger";
+import { runWithSignal } from "./cancellable";
+
+const logger = MainLogger.child({ scope: "db" });
+
+const SLOW_MS = parseInt(process.env.BUNSANE_DB_SLOW_MS ?? '500', 10);
+
+export type DataLoaderKind = 'entity' | 'component' | 'relation';
+
+interface DbStatsInternal {
+    totalCount: number;
+    totalMs: number;
+    maxMs: number;
+    slowCount: number;
+    abortedCount: number;
+    inFlight: number;
+    inFlightMax: number;
+    dataLoaderCalls: { entity: number; component: number; relation: number };
+}
+
+const stats: DbStatsInternal = {
+    totalCount: 0,
+    totalMs: 0,
+    maxMs: 0,
+    slowCount: 0,
+    abortedCount: 0,
+    inFlight: 0,
+    inFlightMax: 0,
+    dataLoaderCalls: { entity: 0, component: 0, relation: 0 },
+};
+
+/**
+ * Per-request counter incremented when current request context is reachable
+ * via the (request as any).__bunsaneStats pointer. We accept that as a
+ * parameter from the call site so this module stays free of GraphQL imports.
+ */
+export interface PerRequestCounters {
+    dbQueryCount: number;
+}
+
+/**
+ * Execute `db.unsafe(sql, params)` with optional AbortSignal cancellation
+ * and roundtrip telemetry. On abort the in-flight query is cancelled via
+ * `Query.cancel()`. Total ms is recorded into module-level stats; calls
+ * over `BUNSANE_DB_SLOW_MS` increment slowCount and emit a warn log.
+ */
+export async function timedUnsafe<T = any>(
+    db: SQL,
+    sql: string,
+    params: any[],
+    signal?: AbortSignal,
+    perRequest?: PerRequestCounters,
+): Promise<T> {
+    const t0 = performance.now();
+    stats.inFlight++;
+    if (stats.inFlight > stats.inFlightMax) stats.inFlightMax = stats.inFlight;
+    if (perRequest) perRequest.dbQueryCount++;
+    let aborted = false;
+    try {
+        const q = (db as any).unsafe(sql, params);
+        return await runWithSignal<T>(q, signal);
+    } catch (err) {
+        if ((err as Error)?.name === 'AbortError' || signal?.aborted) {
+            aborted = true;
+            stats.abortedCount++;
+        }
+        throw err;
+    } finally {
+        const dt = performance.now() - t0;
+        stats.inFlight--;
+        stats.totalCount++;
+        stats.totalMs += dt;
+        if (dt > stats.maxMs) stats.maxMs = dt;
+        if (SLOW_MS > 0 && dt > SLOW_MS && !aborted) {
+            stats.slowCount++;
+            logger.warn(
+                {
+                    durationMs: Math.round(dt),
+                    thresholdMs: SLOW_MS,
+                    sqlSnippet: sql.length > 200 ? sql.slice(0, 200) + '…' : sql,
+                    msg: 'Slow DB call',
+                },
+                'Slow DB call',
+            );
+        }
+    }
+}
+
+/**
+ * Increment the per-kind DataLoader counter. Called from inside DataLoader
+ * batch functions so /metrics + access log can attribute load patterns.
+ *
+ * `perRequest` is loosely typed because RequestContext's `RequestStats`
+ * (defined in core/RequestContext.ts) extends `PerRequestCounters` with
+ * extra fields like `dataLoaderCalls`. We accept either shape here without
+ * importing the higher-level type (which would create a cycle).
+ */
+export function incrementDataLoaderCall(
+    kind: DataLoaderKind,
+    perRequest?: PerRequestCounters | { dataLoaderCalls?: { entity: number; component: number; relation: number } },
+): void {
+    stats.dataLoaderCalls[kind]++;
+    const dlc = (perRequest as any)?.dataLoaderCalls;
+    if (dlc) dlc[kind]++;
+}
+
+/**
+ * Snapshot of accumulated DB stats for the /metrics endpoint.
+ */
+export function getDbStats() {
+    const avgMs = stats.totalCount > 0 ? stats.totalMs / stats.totalCount : 0;
+    return {
+        totalCount: stats.totalCount,
+        totalMs: Math.round(stats.totalMs),
+        maxMs: Math.round(stats.maxMs),
+        avgMs: Number(avgMs.toFixed(2)),
+        slowCount: stats.slowCount,
+        abortedCount: stats.abortedCount,
+        inFlight: stats.inFlight,
+        inFlightMax: stats.inFlightMax,
+        slowThresholdMs: SLOW_MS,
+        dataLoaderCalls: { ...stats.dataLoaderCalls },
+    };
+}
+
+/**
+ * Reset counters. Intended for tests only.
+ */
+export function resetDbStats(): void {
+    stats.totalCount = 0;
+    stats.totalMs = 0;
+    stats.maxMs = 0;
+    stats.slowCount = 0;
+    stats.abortedCount = 0;
+    stats.inFlight = 0;
+    stats.inFlightMax = 0;
+    stats.dataLoaderCalls.entity = 0;
+    stats.dataLoaderCalls.component = 0;
+    stats.dataLoaderCalls.relation = 0;
+}

package/database/sqlHelpers.ts

@@ -12,6 +12,8 @@ export function inList<T>(values: T[], paramIndex: number): { sql: string, param
   
   if (filteredValues.length === 0) return { sql: '()', params: [], newParamIndex: paramIndex };
   
-  const placeholders = Array.from({length: filteredValues.length}, (_, i) => `$${paramIndex + i}`).join(', ');
+  const n = filteredValues.length;
+  let placeholders = '';
+  for (let i = 0; i < n; i++) { placeholders += (i ? ', $' : '$') + (paramIndex + i); }
   return { sql: `(${placeholders})`, params: filteredValues, newParamIndex: paramIndex + filteredValues.length };
 }

package/endpoints/archetypes.ts

@@ -319,19 +319,13 @@ export async function handleStudioArcheTypeDeleteRequest(
             .join(", ");
 
         // Delete in correct order to avoid foreign key constraint violations
-        // 1. Delete from entity_components (junction table)
-        await db.unsafe(
-            `DELETE FROM entity_components WHERE entity_id IN (${idPlaceholders})`,
-            entityIds
-        );
-
-        // 2. Delete from components
+        // 1. Delete from components (membership source of truth)
         await db.unsafe(
             `DELETE FROM components WHERE entity_id IN (${idPlaceholders})`,
             entityIds
         );
 
-        // 3. Delete from entities
+        // 2. Delete from entities
         await db.unsafe(
             `DELETE FROM entities WHERE id IN (${idPlaceholders})`,
             entityIds

package/endpoints/tables.ts

@@ -179,7 +179,12 @@ export async function handleStudioTableDeleteRequest(
 
 export async function handleGetTables(): Promise<Response> {
     try {
-        // Fetch all tables except ECS tables
+        // Exclude framework-internal tables and the legacy entity_components table.
+        // entity_components is no longer written by the framework (Phase 3 of
+        // docs/ENTITY_COMPONENTS_REMOVAL_PLAN.md) but may still exist as an orphan
+        // in upgraded databases. Keeping it out of the Studio listing avoids
+        // exposing a confusingly schema'd legacy table with no ECS UI support.
+        // Users are directed to drop it via the startup orphan-notice log.
         const ecsTables = ['components', 'entities', 'entity_components', 'spatial_ref_sys'];
         const ecsTablePlaceholders = ecsTables.map((_, index) => `$${index + 1}`).join(", ");
 

package/gql/index.ts

@@ -116,7 +116,7 @@ const maskError = (error: any, message: string): GraphQLError => {
     }
     
     // Pass through known application-level GraphQL error codes
-    const isGQLError = (e: any): e is GraphQLError =>
+    const isGQLError = (e: any): e is { message: string; extensions?: Record<string, unknown> } =>
         e instanceof GraphQLError ||
         (e !== null && typeof e === 'object' && 'extensions' in e && 'message' in e && typeof e.message === 'string');
     const knownCodes = ['FORBIDDEN', 'NOT_FOUND', 'BAD_USER_INPUT', 'BAD_REQUEST'];

package/gql/schema/index.ts

@@ -406,6 +406,12 @@ export function isSchemaInput(
 
 // ─── Validation ─────────────────────────────────────────────────────────────────
 
+// Keyed by schema object identity. Safe only when field builders inside the
+// schema are not mutated (via .required()/.optional()/.nullable()) after the
+// first validateInput call for that schema. Module-level schema constants
+// satisfy this constraint; inline schemas constructed per-call simply miss.
+const _zodCache = new WeakMap<object, ZodType>();
+
 export class SchemaValidationError extends Error {
     readonly fieldErrors: Array<{ path: string; message: string }>;
 
@@ -424,11 +430,16 @@ export function validateInput<T extends Record<string, SchemaType>>(
     data: unknown,
     operationName: string = "input",
 ): InferInput<T> {
-    const zodShape: Record<string, ZodType> = {};
-    for (const [key, field] of Object.entries(schema)) {
-        zodShape[key] = field.toZod();
+    let zodObject = _zodCache.get(schema);
+    if (!zodObject) {
+        const zodShape: Record<string, ZodType> = {};
+        for (const [key, field] of Object.entries(schema)) {
+            zodShape[key] = field.toZod();
+        }
+        zodObject = z.object(zodShape);
+        _zodCache.set(schema, zodObject);
     }
-    const result = z.object(zodShape).safeParse(data);
+    const result = zodObject.safeParse(data);
     if (result.success) {
         return result.data as InferInput<T>;
     }

package/gql/visitors/ResolverGeneratorVisitor.ts

@@ -18,24 +18,45 @@ export class ResolverGeneratorVisitor extends GraphVisitor {
         this.services = services;
         this.resolverBuilder = new ResolverBuilder();
         
-        // Add Date scalar resolver
+        // Add Date scalar resolver.
+        // Safety net: gqloom's `z.date()` currently maps to GraphQLString
+        // (see @gqloom/zod isZodDate → GraphQLString), so this custom Date
+        // scalar is rarely wired by the auto-generated archetype schema.
+        // Component-prop leaf resolvers normalize Date → ISO string upstream
+        // (core/archetype/fieldResolvers.ts) so GraphQLString coercion does
+        // not call Date.valueOf() and emit epoch ms. We still harden this
+        // serializer to accept Date, number, and numeric-string inputs in
+        // case a downstream user types a field as the `Date` scalar
+        // directly.
         this.resolverBuilder.addScalarResolver('Date', {
             serialize: (value: any) => {
-                if (value instanceof Date) {
-                    return value.toISOString();
+                if (value === null || value === undefined) return value;
+                if (value instanceof Date) return value.toISOString();
+                if (typeof value === 'number') return new Date(value).toISOString();
+                if (typeof value === 'string') {
+                    if (/^\d+$/.test(value)) {
+                        return new Date(Number(value)).toISOString();
+                    }
+                    return value;
                 }
-                return value;
+                throw new Error(`Date scalar cannot serialize ${typeof value}`);
             },
             parseValue: (value: any) => {
                 if (typeof value === 'string') {
                     return new Date(value);
                 }
+                if (typeof value === 'number') {
+                    return new Date(value);
+                }
                 return value;
             },
             parseLiteral: (ast: any) => {
                 if (ast.kind === 'StringValue') {
                     return new Date(ast.value);
                 }
+                if (ast.kind === 'IntValue') {
+                    return new Date(Number(ast.value));
+                }
                 return null;
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "bunsane",
-    "version": "0.3.2",
+    "version": "0.5.0",
     "author": {
         "name": "yaaruu"
     },
@@ -14,6 +14,27 @@
     ],
     "module": "index.ts",
     "type": "module",
+    "files": [
+        "index.ts",
+        "config",
+        "core",
+        "database",
+        "endpoints",
+        "gql",
+        "plugins",
+        "query",
+        "rest",
+        "scheduler",
+        "service",
+        "storage",
+        "studio/dist",
+        "swagger",
+        "types",
+        "upload",
+        "utils",
+        "tsconfig.json",
+        "CHANGELOG.md"
+    ],
     "scripts": {
         "build": "bun run build:studio && tsc",
         "build:studio": "cd studio && bun install && bun run build",

package/query/CTENode.ts

@@ -1,12 +1,14 @@
 import { QueryNode } from "./QueryNode";
 import type { QueryResult } from "./QueryNode";
 import { QueryContext } from "./QueryContext";
+import { getMembershipTable } from "./membershipSource";
 
 export class CTENode extends QueryNode {
     public execute(context: QueryContext): QueryResult {
         // Generate CTE for base entity filtering
         const componentIds = Array.from(context.componentIds);
         const excludedIds = Array.from(context.excludedComponentIds);
+        const membershipTable = getMembershipTable();
 
         if (componentIds.length === 0) {
             throw new Error("CTENode requires at least one component type to filter on");
@@ -26,7 +28,7 @@ export class CTENode extends QueryNode {
         if (excludedIds.length > 0) {
             const excludedPlaceholders = excludedIds.map((id) => `$${context.addParam(id)}`).join(', ');
             exclusionCondition = ` AND NOT EXISTS (
-                SELECT 1 FROM entity_components ec_ex
+                SELECT 1 FROM ${membershipTable} ec_ex
                 WHERE ec_ex.entity_id = ec.entity_id
                 AND ec_ex.type_id IN (${excludedPlaceholders})
                 AND ec_ex.deleted_at IS NULL
@@ -45,7 +47,7 @@ export class CTENode extends QueryNode {
             // Single component - simple query, no INTERSECT needed
             const paramIdx = context.addParam(componentIds[0]);
             cteSql += `    SELECT DISTINCT ec.entity_id\n`;
-            cteSql += `    FROM entity_components ec\n`;
+            cteSql += `    FROM ${membershipTable} ec\n`;
             cteSql += `    WHERE ec.type_id = $${paramIdx}::text\n`;
             cteSql += `    AND ec.deleted_at IS NULL\n`;
             if (cursorCondition) cteSql += `    ${cursorCondition.trim()}\n`;
@@ -57,7 +59,7 @@ export class CTENode extends QueryNode {
             // then efficiently merge results, avoiding Cartesian product explosion
             const intersectQueries = componentIds.map((compId) => {
                 const paramIdx = context.addParam(compId);
-                let subquery = `SELECT ec.entity_id FROM entity_components ec WHERE ec.type_id = $${paramIdx}::text AND ec.deleted_at IS NULL`;
+                let subquery = `SELECT ec.entity_id FROM ${membershipTable} ec WHERE ec.type_id = $${paramIdx}::text AND ec.deleted_at IS NULL`;
                 // Add cursor/exclusion conditions to each subquery for efficiency
                 if (cursorCondition) subquery += cursorCondition;
                 if (exclusionCondition) subquery += exclusionCondition;