@everystack/api 0.2.12 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/api",
-  "version": "0.2.12",
+  "version": "0.4.0",
   "description": "PostgREST-compatible HTTP handler + typed fetch client for Drizzle ORM",
   "license": "AGPL-3.0-only",
   "author": "Scalable Technology, Inc. <licensing@scalable.technology>",

package/src/handler/index.ts

@@ -522,8 +522,81 @@ function transformBodyKeys(body: Record<string, unknown>, table: DrizzleTable):
   return result;
 }
 
-export function createHandler(db: DrizzleDb, schema: Schema, options?: HandlerOptions): Handler {
+/** The name a drizzle pgTable knows itself by in SQL, or null for a non-table export. */
+function sqlNameOf(value: unknown): string | null {
+  if (!value || typeof value !== 'object') return null;
+  const name = (value as Record<symbol, unknown>)[Symbol.for('drizzle:Name')];
+  return typeof name === 'string' ? name : null;
+}
+
+/** Export-key ↔ SQL-name pairs for every table whose two spellings differ. */
+function tableNamePairs(schema: Schema): Array<{ exportKey: string; sqlName: string }> {
+  const pairs: Array<{ exportKey: string; sqlName: string }> = [];
+  for (const [exportKey, value] of Object.entries(schema)) {
+    const sqlName = sqlNameOf(value);
+    if (sqlName && sqlName !== exportKey) pairs.push({ exportKey, sqlName });
+  }
+  return pairs;
+}
+
+/** The schema with each table reachable under BOTH spellings (existing keys win). */
+function expandSchema(schema: Schema, pairs: Array<{ exportKey: string; sqlName: string }>): Schema {
+  if (pairs.length === 0) return schema;
+  const expanded: Schema = { ...schema };
+  for (const { exportKey, sqlName } of pairs) {
+    if (!(sqlName in expanded)) expanded[sqlName] = schema[exportKey];
+  }
+  return expanded;
+}
+
+/**
+ * Table-keyed options written in EITHER naming domain apply to both spellings.
+ * `deriveHandlerConfig` emits SQL names; hand-written configs use export keys —
+ * each key gains its twin (same value reference), so neither authoring style
+ * can strand a table behind the other domain's gate.
+ */
+function expandTableKeyedOptions(
+  options: HandlerOptions | undefined,
+  pairs: Array<{ exportKey: string; sqlName: string }>,
+): HandlerOptions | undefined {
+  if (!options || pairs.length === 0) return options;
+  const twin = (name: string): string | undefined =>
+    pairs.find((p) => p.exportKey === name)?.sqlName ?? pairs.find((p) => p.sqlName === name)?.exportKey;
+  const expandList = (list: string[]): string[] =>
+    [...new Set(list.flatMap((name) => { const t = twin(name); return t ? [name, t] : [name]; }))];
+  const expandMap = <T,>(map: Record<string, T>): Record<string, T> => {
+    const out: Record<string, T> = { ...map };
+    for (const key of Object.keys(map)) {
+      const t = twin(key);
+      if (t && !(t in out)) out[t] = map[key];
+    }
+    return out;
+  };
+  return {
+    ...options,
+    ...(options.exposedTables ? { exposedTables: expandList(options.exposedTables) } : {}),
+    ...(options.hiddenColumns ? { hiddenColumns: expandMap(options.hiddenColumns) } : {}),
+    ...(options.protectedFields ? { protectedFields: expandMap(options.protectedFields) } : {}),
+    ...(options.rowOwnership ? { rowOwnership: expandMap(options.rowOwnership) } : {}),
+    ...(options.relations ? { relations: expandMap(options.relations) } : {}),
+    ...(options.hooks ? { hooks: expandMap(options.hooks) } : {}),
+    ...(options.softDelete?.tables
+      ? { softDelete: { ...options.softDelete, tables: expandList(options.softDelete.tables) } }
+      : {}),
+  };
+}
+
+export function createHandler(db: DrizzleDb, rawSchema: Schema, rawOptions?: HandlerOptions): Handler {
+  // The naming seam: URLs, exposedTables, and relation targets historically mixed
+  // drizzle export keys (`texturePacks`) with SQL names (`texture_packs`), and any
+  // multi-word table failed one gate or the other — both spellings 404'd. Collapse
+  // the two domains here, once: both spellings route, and options in either domain
+  // apply. The root listing below stays one entry per table (the SQL name).
+  const namePairs = tableNamePairs(rawSchema);
+  const schema = expandSchema(rawSchema, namePairs);
+  const options = expandTableKeyedOptions(rawOptions, namePairs);
   const tableNames = new Set(Object.keys(schema));
+  const canonicalTables = [...new Set(Object.entries(rawSchema).map(([key, value]) => sqlNameOf(value) ?? key))];
 
   return async (request: Request): Promise<Response> => {
     const url = new URL(request.url);
@@ -583,11 +656,12 @@ export function createHandler(db: DrizzleDb, schema: Schema, options?: HandlerOp
       }
     }
 
-    // Root path — table listing, always public
+    // Root path — table listing, always public. One entry per table (SQL name),
+    // regardless of how many spellings route to it.
     if (pathSegments.length === 0) {
       const tables = options?.exposedTables
-        ? Array.from(tableNames).filter(t => options.exposedTables!.includes(t))
-        : Array.from(tableNames);
+        ? canonicalTables.filter(t => options.exposedTables!.includes(t))
+        : canonicalTables;
       return json({ tables }, 200);
     }