@frigear-nu/module-kit 0.0.4 → 0.0.6

package/README.md

@@ -116,6 +116,38 @@ call with the merged columns and deduplicated imports. The base `schema` file mu
 `sqliteTable('users', { ... })`) matching `name`, since it determines which factory (`sqliteTable`/`pgTable`/etc.) and
 SQL table name to use for the merged result.
 
+`name` also accepts an array, so a single `file` can export extension columns for several tables in one go, the same
+way `registerDatabaseTable` does:
+
+```ts
+extendDatabaseTable(nuxt, {
+  name: ['users', 'userPasskeys'],
+  resolver: createResolver(import.meta.url),
+  file: dialect => `./runtime/db/extra.${dialect}`,
+})
+```
+
+```ts
+// runtime/db/extra.sqlite.ts
+export const users = sqliteTable('users', {
+  locale: text().default('da'),
+})
+export const userPasskeys = sqliteTable('user_passkeys', {
+  label: text(),
+})
+```
+
+`name` can also be omitted entirely, in which case `file` is registered against every table that generates a schema -
+whichever table(s) it actually has a matching export for pick up its columns, exactly as the shared Nuxt-layer
+`server/db/extend.<dialect>.ts` files already do; tables with no matching export in `file` are left untouched:
+
+```ts
+extendDatabaseTable(nuxt, {
+  resolver: createResolver(import.meta.url),
+  file: dialect => `./runtime/db/extra.${dialect}`,
+})
+```
+
 #### Using a `factory`
 
 Pass `factory` to `registerDatabaseTable` when you need shared defaults (e.g. timestamps) applied consistently across

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=4.0.0"
   },
-  "version": "0.0.4",
+  "version": "0.0.6",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"

package/dist/runtime/utils/regular-table.d.ts

@@ -3,6 +3,7 @@ export type ParsedTableExport = {
     tableCall?: {
         callee: string;
         tableName: string;
+        extraArgs?: string[];
     };
     /** Column (or spread) entries keyed by property name, in source order. Values are the raw `key: value` source text. */
     properties: Map<string, string>;
@@ -21,3 +22,10 @@ export type ParsedTableExport = {
  *   when `exportName` is `'default'`
  */
 export declare const parseRegularTableExport: (filePath: string, exportName: string) => ParsedTableExport | undefined;
+/**
+ * Lists the names of every named export in a "regular" drizzle schema file that looks like a table (or columns)
+ * export - i.e. every export that `parseRegularTableExport` would be able to parse. Used by `registerDatabaseTable`
+ * to auto-discover table names when none are explicitly provided. Does not include the `default` export, since it
+ * has no name to register a table under.
+ */
+export declare const listRegularTableExportNames: (filePath: string) => string[];

package/dist/runtime/utils/regular-table.js

@@ -1,8 +1,10 @@
 import { readFileSync } from "node:fs";
 import ts from "typescript";
-export const parseRegularTableExport = (filePath, exportName) => {
+const parseSource = (filePath) => {
   const text = readFileSync(filePath, "utf8");
-  const source = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  return ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+};
+const collectImports = (source) => {
   const imports = /* @__PURE__ */ new Map();
   for (const statement of source.statements) {
     if (ts.isImportDeclaration(statement) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && ts.isStringLiteralLike(statement.moduleSpecifier)) {
@@ -11,43 +13,64 @@ export const parseRegularTableExport = (filePath, exportName) => {
       imports.set(statement.moduleSpecifier.text, specifiers);
     }
   }
-  const toResult = (initializer) => {
-    let objectLiteral;
-    let tableCall;
-    if (ts.isCallExpression(initializer)) {
-      const args = initializer.arguments;
-      if (args.length >= 2 && ts.isStringLiteralLike(args[0]) && ts.isObjectLiteralExpression(args[1])) {
-        tableCall = { callee: initializer.expression.getText(), tableName: args[0].text };
-        objectLiteral = args[1];
-      } else if (args.length === 1 && ts.isObjectLiteralExpression(args[0])) {
-        objectLiteral = args[0];
-      }
-    } else if (ts.isObjectLiteralExpression(initializer)) {
-      objectLiteral = initializer;
+  return imports;
+};
+const toTableResult = (initializer, imports) => {
+  let objectLiteral;
+  let tableCall;
+  if (ts.isCallExpression(initializer)) {
+    const args = initializer.arguments;
+    if (args.length >= 2 && ts.isStringLiteralLike(args[0]) && ts.isObjectLiteralExpression(args[1])) {
+      const extraArgs = args.length > 2 ? args.slice(2).map((arg) => arg.getText()) : void 0;
+      tableCall = { callee: initializer.expression.getText(), tableName: args[0].text, extraArgs };
+      objectLiteral = args[1];
+    } else if (args.length === 1 && ts.isObjectLiteralExpression(args[0])) {
+      objectLiteral = args[0];
     }
-    if (!objectLiteral) return void 0;
-    const properties = /* @__PURE__ */ new Map();
-    for (const property of objectLiteral.properties) {
-      if (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) {
-        properties.set(property.name.getText(), property.getText());
-      } else if (ts.isSpreadAssignment(property)) {
-        properties.set(`__spread_${properties.size}`, property.getText());
-      }
+  } else if (ts.isObjectLiteralExpression(initializer)) {
+    objectLiteral = initializer;
+  }
+  if (!objectLiteral) return void 0;
+  const properties = /* @__PURE__ */ new Map();
+  for (const property of objectLiteral.properties) {
+    if (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) {
+      properties.set(property.name.getText(), property.getText());
+    } else if (ts.isSpreadAssignment(property)) {
+      properties.set(`__spread_${properties.size}`, property.getText());
     }
-    return { tableCall, properties, imports };
-  };
+  }
+  return { tableCall, properties, imports };
+};
+export const parseRegularTableExport = (filePath, exportName) => {
+  const source = parseSource(filePath);
+  const imports = collectImports(source);
   for (const statement of source.statements) {
     if (ts.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
       for (const declaration of statement.declarationList.declarations) {
         if (ts.isIdentifier(declaration.name) && declaration.name.text === exportName && declaration.initializer) {
-          const result = toResult(declaration.initializer);
+          const result = toTableResult(declaration.initializer, imports);
           if (result) return result;
         }
       }
     } else if (exportName === "default" && ts.isExportAssignment(statement) && !statement.isExportEquals) {
-      const result = toResult(statement.expression);
+      const result = toTableResult(statement.expression, imports);
       if (result) return result;
     }
   }
   return void 0;
 };
+export const listRegularTableExportNames = (filePath) => {
+  const source = parseSource(filePath);
+  const imports = collectImports(source);
+  const names = [];
+  for (const statement of source.statements) {
+    if (ts.isVariableStatement(statement) && statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name) && declaration.initializer && toTableResult(declaration.initializer, imports)) {
+          names.push(declaration.name.text);
+        }
+      }
+    }
+  }
+  return names;
+};

package/dist/runtime/utils/server.d.ts

@@ -42,12 +42,22 @@ export declare const defineExtendableTable: <T>(table: TableDefinerFn<T>) => (pr
  */
 export declare const onDatabaseSchemaExtend: (nuxt: Nuxt, extender: DbExtenderFn) => Promise<() => void>;
 type DatabaseTableOptions = {
-    name: string;
+    /**
+     * The name of the table's export (e.g. `users`). Pass an array of names (e.g. `['users', 'userPasskeys']`) to
+     * register several tables that are exported from the same `schema` file in one go - they're generated into a
+     * single file so that tables can reference each other (e.g. a foreign key `.references(() => users.id)`). An
+     * array of names (or omitting `name` entirely) is only supported when `factory` is omitted.
+     *
+     * When omitted, every table-like export in `schema` (and its extension files) is registered automatically - this
+     * is equivalent to passing an array of every such export's name.
+     */
+    name?: string | string[];
     /**
      * The exported factory function name to call with merged extension columns (e.g. `defineUsersTable`), as produced
      * by `defineExtendableTable`. When omitted, `schema` (and every registered/layer extension file) is treated as a
      * "regular" drizzle file - e.g. `export const users = sqliteTable('users', { ... })` - and its columns are merged
-     * directly, without requiring any helper wrapper.
+     * directly, without requiring any helper wrapper. Only supported when `name` is a single string, since the
+     * factory is called once with a single table's columns.
      */
     factory?: string;
     resolver: ReturnType<typeof createResolver>;
@@ -56,7 +66,16 @@ type DatabaseTableOptions = {
     extensionFile?: (dialect: string) => string;
 };
 type TableExtensionOptions = {
-    name: string;
+    /**
+     * The name of the table to extend (e.g. `users`). Pass an array of names (e.g. `['users', 'userPasskeys']`) when
+     * `file` exports columns for several tables at once - it's resolved and parsed once per matching table, same as
+     * if `extendDatabaseTable` had been called separately for each name with the same `file`.
+     *
+     * When omitted, `file` is registered against every table - whichever table(s) it actually has a matching export
+     * for (parsed the same way as the shared Nuxt-layer `server/db/extend.<dialect>.ts` files) pick up its columns;
+     * tables it has no matching export for are unaffected.
+     */
+    name?: string | string[];
     resolver: ReturnType<typeof createResolver>;
     file: (dialect: string) => string;
 };
@@ -71,6 +90,10 @@ export declare const extendDatabaseTable: (nuxt: Nuxt, options: TableExtensionOp
  * table by importing the named `factory` from `schema`, merging in any columns registered
  * through `extendDatabaseTable` and any Nuxt-layer extension files, then calling the factory with
  * `{ name, columns }`.
+ *
+ * When `name` is an array, or omitted entirely, every (named or auto-discovered) table is generated into a single
+ * file - this lets tables declared in the same `schema` file reference each other directly (e.g. a foreign key
+ * `.references(() => users.id)` from a `userPasskeys` table), since they share the same module scope.
  */
 export declare const registerDatabaseTable: (nuxt: Nuxt, options: DatabaseTableOptions) => Promise<() => void>;
 export {};

package/dist/runtime/utils/server.js

@@ -1,6 +1,6 @@
 import { addTemplate, createResolver } from "@nuxt/kit";
 import { existsSync } from "node:fs";
-import { parseRegularTableExport } from "./regular-table.js";
+import { listRegularTableExportNames, parseRegularTableExport } from "./regular-table.js";
 export const defineTableColumns = (columns) => {
   return columns;
 };
@@ -13,8 +13,9 @@ export const onDatabaseSchemaExtend = async (nuxt, extender) => {
   return nuxt.hook("hub:db:schema:extend", extender);
 };
 export const extendDatabaseTable = (nuxt, options) => {
+  const names = options.name === void 0 ? void 0 : Array.isArray(options.name) ? options.name : [options.name];
   nuxt.hook("module-kit:db:table:extend", async ({ name, dialect, paths }) => {
-    if (name === options.name) {
+    if (names === void 0 || names.includes(name)) {
       const file = await options.resolver.resolvePath(options.file(dialect));
       if (existsSync(file)) paths.push(file);
     }
@@ -22,73 +23,102 @@ export const extendDatabaseTable = (nuxt, options) => {
 };
 export const registerDatabaseTable = (nuxt, options) => {
   const { name, factory, resolver, schema, override, extensionFile } = options;
+  if (factory && (name === void 0 || Array.isArray(name))) {
+    throw new Error(
+      '[module-kit] registerDatabaseTable requires a single "name" (not an array, and not omitted) when "factory" is set. Omit "factory" to register multiple (or auto-discovered) tables from the same regular drizzle schema file.'
+    );
+  }
   return onDatabaseSchemaExtend(nuxt, async ({ dialect, paths }) => {
     if (override && override !== "default") {
       paths.push(await resolver.resolvePath(override, { cwd: nuxt.options.rootDir }));
       return;
     }
-    const registered = [];
-    await nuxt.callHook("module-kit:db:table:extend", { name, dialect, paths: registered });
-    const extensions = registered.map((file) => ({ file, legacy: true }));
+    const schemaPath = await resolver.resolvePath(schema(dialect));
+    const names = name === void 0 ? listRegularTableExportNames(schemaPath) : Array.isArray(name) ? name : [name];
+    if (names.length === 0) {
+      throw new Error(
+        `[module-kit] Could not find any table exports in "${schemaPath}" to register. "schema" must be a regular drizzle file, e.g. \`export const users = sqliteTable('users', { ... })\`.`
+      );
+    }
+    const extensionsByName = /* @__PURE__ */ new Map();
+    for (const tableName2 of names) {
+      const registered = [];
+      await nuxt.callHook("module-kit:db:table:extend", { name: tableName2, dialect, paths: registered });
+      extensionsByName.set(tableName2, registered.map((file) => ({ file, legacy: true })));
+    }
     const layerRoots = [...new Set(nuxt.options._layers?.map((layer) => layer.config.rootDir).reverse() ?? [])];
     for (const root of [...layerRoots.filter((root2) => root2 !== nuxt.options.rootDir), nuxt.options.rootDir]) {
       const rootResolver = createResolver(root);
       const extensionPath = await rootResolver.resolvePath(extensionFile?.(dialect) ?? `server/db/extend.${dialect}.ts`);
       if (!extensionFile) {
-        const legacyPath = await rootResolver.resolvePath(`server/db/${name}.extend.${dialect}`);
-        if (existsSync(legacyPath)) extensions.push({ file: legacyPath, legacy: true });
+        for (const tableName2 of names) {
+          const legacyPath = await rootResolver.resolvePath(`server/db/${tableName2}.extend.${dialect}`);
+          if (existsSync(legacyPath)) extensionsByName.get(tableName2).push({ file: legacyPath, legacy: true });
+        }
+      }
+      if (existsSync(extensionPath)) {
+        for (const tableName2 of names) extensionsByName.get(tableName2).push({ file: extensionPath, legacy: false });
       }
-      if (existsSync(extensionPath)) extensions.push({ file: extensionPath, legacy: false });
     }
     if (!factory) {
-      const schemaPath = await resolver.resolvePath(schema(dialect));
-      const template2 = buildRegularTableTemplate({ name, dialect, schemaPath, extensionFiles: extensions.map(({ file }) => file) });
+      const template2 = buildRegularTableTemplate({ names, dialect, schemaPath, extensionsByName });
       paths.push(template2.dst);
       return;
     }
+    const tableName = names[0];
+    const extensions = extensionsByName.get(tableName);
     const template = addTemplate({
-      filename: `${name}/schema.${dialect}.ts`,
+      filename: `${tableName}/schema.${dialect}.ts`,
       write: true,
       getContents: () => `
 import { ${factory} } from ${JSON.stringify(resolver.resolve(schema(dialect)))}
 ${extensions.map(({ file }, index) => `import * as extra${index} from ${JSON.stringify(file)}`).join("\n")}
-export const ${name} = ${factory}({ name: ${JSON.stringify(name)}, columns: { ${extensions.map(({ legacy }, index) => legacy ? `...(extra${index}[${JSON.stringify(name)} as keyof typeof extra${index}] ?? Object.entries(extra${index}).find(([key]) => key === 'default')?.[1] ?? {})` : `...(extra${index}[${JSON.stringify(name)} as keyof typeof extra${index}] ?? {})`).join(", ")} } })
+export const ${tableName} = ${factory}({ name: ${JSON.stringify(tableName)}, columns: { ${extensions.map(({ legacy }, index) => legacy ? `...(extra${index}[${JSON.stringify(tableName)} as keyof typeof extra${index}] ?? Object.entries(extra${index}).find(([key]) => key === 'default')?.[1] ?? {})` : `...(extra${index}[${JSON.stringify(tableName)} as keyof typeof extra${index}] ?? {})`).join(", ")} } })
 `
     });
     paths.push(template.dst);
   });
 };
 const buildRegularTableTemplate = (options) => {
-  const { name, dialect, schemaPath, extensionFiles } = options;
-  const base = parseRegularTableExport(schemaPath, name);
-  if (!base?.tableCall) {
-    throw new Error(
-      `[module-kit] Could not find a table export named "${name}" in "${schemaPath}". When "factory" is omitted, "schema" must be a regular drizzle file, e.g. \`export const ${name} = sqliteTable(${JSON.stringify(name)}, { ... })\`.`
-    );
-  }
-  const properties = new Map(base.properties);
-  const importsByModule = new Map([...base.imports].map(([module, specifiers]) => [module, new Set(specifiers)]));
-  for (const file of extensionFiles) {
-    const parsed = parseRegularTableExport(file, name);
-    if (!parsed) continue;
-    for (const [key, value] of parsed.properties) {
-      properties.delete(key);
-      properties.set(key, value);
+  const { names, dialect, schemaPath, extensionsByName } = options;
+  const importsByModule = /* @__PURE__ */ new Map();
+  const tables = names.map((name) => {
+    const base = parseRegularTableExport(schemaPath, name);
+    if (!base?.tableCall) {
+      throw new Error(
+        `[module-kit] Could not find a table export named "${name}" in "${schemaPath}". When "factory" is omitted, "schema" must be a regular drizzle file, e.g. \`export const ${name} = sqliteTable(${JSON.stringify(name)}, { ... })\`.`
+      );
     }
-    for (const [module, specifiers] of parsed.imports) {
+    const properties = new Map(base.properties);
+    for (const [module, specifiers] of base.imports) {
       const set = importsByModule.get(module) ?? /* @__PURE__ */ new Set();
       for (const specifier of specifiers) set.add(specifier);
       importsByModule.set(module, set);
     }
-  }
+    for (const { file } of extensionsByName.get(name) ?? []) {
+      const parsed = parseRegularTableExport(file, name);
+      if (!parsed) continue;
+      for (const [key, value] of parsed.properties) {
+        properties.delete(key);
+        properties.set(key, value);
+      }
+      for (const [module, specifiers] of parsed.imports) {
+        const set = importsByModule.get(module) ?? /* @__PURE__ */ new Set();
+        for (const specifier of specifiers) set.add(specifier);
+        importsByModule.set(module, set);
+      }
+    }
+    return { name, tableCall: base.tableCall, properties };
+  });
   return addTemplate({
-    filename: `${name}/schema.${dialect}.ts`,
+    filename: `${names.join("+")}/schema.${dialect}.ts`,
     write: true,
     getContents: () => `
 ${[...importsByModule].map(([module, specifiers]) => `import { ${[...specifiers].join(", ")} } from ${JSON.stringify(module)}`).join("\n")}
-export const ${name} = ${base.tableCall.callee}(${JSON.stringify(base.tableCall.tableName)}, {
+${tables.map(({ name, tableCall, properties }) => `
+export const ${name} = ${tableCall.callee}(${JSON.stringify(tableCall.tableName)}, {
 ${[...properties.values()].map((property) => `  ${property},`).join("\n")}
-})
-`
+}${tableCall.extraArgs?.length ? `, ${tableCall.extraArgs.join(", ")}` : ""})
+`).join("")}`
   });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frigear-nu/module-kit",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "private": false,
   "description": "Frigear Module Kit",