@frigear-nu/module-kit 0.0.2

package/README.md

@@ -0,0 +1,41 @@
+# @frigar-nu/module-kit
+
+A simple nuxt module to simplify development of other nuxt modules within frigear.
+
+## Purpose
+
+- Be a shared module kit for building nuxt modules within frigear – as generic as possible within the frigear requirements
+- E.g building a 'user' or 'blog' or 'post' module for frigear-nu
+
+## Extending a database table
+
+Modules can register a table schema using `extendDatabaseTable` from `@frigear-nu/module-kit/utils`:
+
+```ts
+extendDatabaseTable(nuxt, {
+  name: 'users',
+  factory: 'defineUsersTable',
+  resolver: createResolver(import.meta.url),
+  schema: dialect => `./runtime/db/schema.${dialect}`,
+  override: options.settings?.schemas?.users,
+})
+```
+
+The schema file exports the named factory, which accepts an object of additional columns and returns a table. The factory must spread the received `extra` columns *last* in the object passed to the table builder (after every one of its own fields, including timestamps), so extended columns always end up last in the generated migration, matching the order they were registered in. Other modules can register column files during setup:
+
+```ts
+registerDatabaseTableExtension(nuxt, {
+  name: 'users',
+  resolver: createResolver(import.meta.url),
+  file: dialect => `./runtime/db/extra.${dialect}`,
+})
+```
+
+Each extension file exports column objects named for their tables. For example, a Nuxt layer can extend several tables in `server/db/extend.sqlite.ts`:
+
+```ts
+export const users = defineExtendedColumns({ locale: text().default('da') })
+export const posts = defineExtendedColumns({ summary: text() })
+```
+
+Only the export matching the table being built is used. Existing registered files are merged in registration order (later fields replace earlier fields); missing files for a dialect are skipped. Registered files with legacy default exports still work. Nuxt layer files are merged next, from base layers toward the host application. Older `server/db/<name>.extend.<dialect>` files with default exports are also loaded before each layer's shared file, so a shared export can override them. Pass `extensionFile: dialect => 'path/to/columns.' + dialect + '.ts'` to change the per-layer file location. If `override` is a path instead of `'default'`, the host schema replaces the generated table entirely; the path is resolved from the application's root directory.

package/dist/module.d.mts

@@ -0,0 +1,10 @@
+import * as _nuxt_schema from '@nuxt/schema';
+export * from '../dist/runtime/utils/index.js';
+
+interface ModuleOptions {
+    _modules?: string[];
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@frigear-nu/module-kit",
+  "configKey": "moduleKit",
+  "compatibility": {
+    "nuxt": ">=4.0.0"
+  },
+  "version": "0.0.2",
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,28 @@
+import { defineNuxtModule, createResolver } from '@nuxt/kit';
+export * from '../dist/runtime/utils/index.js';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@frigear-nu/module-kit",
+    configKey: "moduleKit",
+    compatibility: {
+      nuxt: ">=4.0.0"
+    }
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    _modules: []
+  },
+  setup(_options, _nuxt) {
+    createResolver(import.meta.url);
+    _nuxt.options.moduleKit ||= {};
+    _nuxt.options.moduleKit._modules = [
+      .../* @__PURE__ */ new Set([
+        ..._nuxt.options.moduleKit._modules ?? [],
+        ..._options._modules ?? []
+      ])
+    ];
+  }
+});
+
+export { module$1 as default };

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

@@ -0,0 +1,6 @@
+export * from './manifest.js';
+export * from './pages.js';
+export * from './template.js';
+export * from './server.js';
+export * from './module.js';
+export * from './url.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./manifest.js";
+export * from "./pages.js";
+export * from "./template.js";
+export * from "./server.js";
+export * from "./module.js";
+export * from "./url.js";

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

@@ -0,0 +1,2 @@
+import { type Resolver } from '@nuxt/kit';
+export declare const addModuleManifest: (moduleName: string, _resolver: Resolver) => void;

package/dist/runtime/utils/manifest.js

@@ -0,0 +1,10 @@
+import { addTemplate } from "@nuxt/kit";
+export const addModuleManifest = (moduleName, _resolver) => {
+  addTemplate({
+    filename: `${moduleName}.json`,
+    write: true,
+    getContents: () => {
+      return `export default ${JSON.stringify({ moduleName }, null, 2)}`;
+    }
+  });
+};

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

@@ -0,0 +1,2 @@
+import type { Nuxt } from '@nuxt/schema';
+export declare const registerModule: (moduleName: string, nuxt: Nuxt) => void;

package/dist/runtime/utils/module.js

@@ -0,0 +1,8 @@
+export const registerModule = (moduleName, nuxt) => {
+  nuxt.options.moduleKit ||= {};
+  const registeredModules = Array.isArray(nuxt.options.moduleKit._modules) ? nuxt.options.moduleKit._modules : [];
+  nuxt.options.moduleKit._modules = registeredModules;
+  if (!registeredModules.includes(moduleName)) {
+    registeredModules.push(moduleName);
+  }
+};

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

@@ -0,0 +1,2 @@
+import type { NuxtPage } from '@nuxt/schema';
+export declare const defineModulePage: (moduleName: string, page: NuxtPage) => NuxtPage;

package/dist/runtime/utils/pages.js

@@ -0,0 +1,9 @@
+export const defineModulePage = (moduleName, page) => {
+  return {
+    ...page,
+    meta: {
+      moduleName,
+      ...page.meta
+    }
+  };
+};

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

@@ -0,0 +1,36 @@
+import { createResolver } from '@nuxt/kit';
+import type { Nuxt } from '@nuxt/schema';
+import type { ColumnBuilderBase } from 'drizzle-orm';
+type DbExtenderFn = (props: {
+    dialect: string;
+    paths: string[];
+}) => void | Promise<void>;
+type TableExtenderFn = (props: {
+    name: string;
+    dialect: string;
+    paths: string[];
+}) => void | Promise<void>;
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        'hub:db:schema:extend': DbExtenderFn;
+        'module-kit:db:table:extend': TableExtenderFn;
+    }
+}
+export declare const defineExtendedColumns: <T extends Record<string, ColumnBuilderBase>>(columns: T) => T;
+export declare const extendDatabaseSchema: (nuxt: Nuxt, extender: DbExtenderFn) => Promise<() => void>;
+type DatabaseTableOptions = {
+    name: string;
+    factory: string;
+    resolver: ReturnType<typeof createResolver>;
+    schema: (dialect: string) => string;
+    override?: string;
+    extensionFile?: (dialect: string) => string;
+};
+type TableExtensionOptions = {
+    name: string;
+    resolver: ReturnType<typeof createResolver>;
+    file: (dialect: string) => string;
+};
+export declare const registerDatabaseTableExtension: (nuxt: Nuxt, options: TableExtensionOptions) => void;
+export declare const extendDatabaseTable: (nuxt: Nuxt, options: DatabaseTableOptions) => Promise<() => void>;
+export {};

package/dist/runtime/utils/server.js

@@ -0,0 +1,48 @@
+import { addTemplate, createResolver } from "@nuxt/kit";
+import { existsSync } from "node:fs";
+export const defineExtendedColumns = (columns) => {
+  return columns;
+};
+export const extendDatabaseSchema = async (nuxt, extender) => {
+  return nuxt.hook("hub:db:schema:extend", extender);
+};
+export const registerDatabaseTableExtension = (nuxt, options) => {
+  nuxt.hook("module-kit:db:table:extend", async ({ name, dialect, paths }) => {
+    if (name === options.name) {
+      const file = await options.resolver.resolvePath(options.file(dialect));
+      if (existsSync(file)) paths.push(file);
+    }
+  });
+};
+export const extendDatabaseTable = (nuxt, options) => {
+  const { name, factory, resolver, schema, override, extensionFile } = options;
+  return extendDatabaseSchema(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 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 });
+      }
+      if (existsSync(extensionPath)) extensions.push({ file: extensionPath, legacy: false });
+    }
+    const template = addTemplate({
+      filename: `${name}/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}({ ${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(", ")} })
+`
+    });
+    paths.push(template.dst);
+  });
+};

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

@@ -0,0 +1 @@
+export declare const buildUseModuleInfoTemplate: () => void;

package/dist/runtime/utils/template.js

@@ -0,0 +1,2 @@
+export const buildUseModuleInfoTemplate = () => {
+};

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

@@ -0,0 +1,2 @@
+export declare const moduleUrl: (moduleName: string, path?: string) => string;
+export declare const moduleApiUrl: (moduleName: string, path?: string) => string;

package/dist/runtime/utils/url.js

@@ -0,0 +1,15 @@
+import { kebabCase } from "scule";
+import { joinURL, withLeadingSlash } from "ufo";
+export const moduleUrl = (moduleName, path) => {
+  return withLeadingSlash(joinURL(
+    path?.startsWith("/") ? "" : kebabCase(moduleName),
+    path ?? ""
+  ));
+};
+export const moduleApiUrl = (moduleName, path) => {
+  return withLeadingSlash(joinURL(
+    "api",
+    path?.startsWith("/") ? "" : kebabCase(moduleName),
+    path ?? ""
+  ));
+};

package/dist/types.d.mts

@@ -0,0 +1,5 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'
+
+export * from '../dist/runtime/utils/index.js'

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@frigear-nu/module-kit",
+  "version": "0.0.2",
+  "type": "module",
+  "private": false,
+  "description": "Frigear Module Kit",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/module-kit"
+  },
+  "license": "MIT",
+  "main": "./dist/module.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./utils": {
+      "types": "./dist/runtime/utils/index.d.ts",
+      "import": "./dist/runtime/utils/index.js",
+      "default": "./dist/runtime/utils/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "dependencies": {
+    "@nuxt/kit": "^4.5.2",
+    "defu": "^6.1.7",
+    "scule": "^1.3.0",
+    "ufo": "^1.6.4",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.4.2",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.5.2",
+    "@nuxt/test-utils": "^4.3.2",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.10.0",
+    "nuxt": "^4.5.2",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1",
+    "vue-tsc": "^3.3.11"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "^0.45.3",
+    "drizzle-kit": "^0.31.11"
+  },
+  "scripts": {
+    "postinstall": "nuxt-module-build build --stub && nuxt prepare && nuxt-module-build build",
+    "build": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  }
+}