@classytic/arc 2.15.4 → 2.16.0

package/dist/generate-CYac-OLv.mjs

@@ -0,0 +1,654 @@
+import { t as pluralize } from "./pluralize-B9M8xvy-.mjs";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/cli/commands/generate/name-helpers.ts
+/**
+* Case conversion for resource-name normalisation.
+*
+* `arc generate r org-profile` accepts kebab-case names from the CLI;
+* templates need PascalCase for class identifiers (`OrgProfileRepository`)
+* and camelCase for variable / instance names (`orgProfileResource`).
+* Centralising the converters here keeps every template emitting the
+* same shape — no one-off `.charAt(0).toUpperCase()` chains scattered
+* through template code.
+*/
+/** Convert kebab-case to PascalCase: `org-profile` → `OrgProfile`. */
+function toPascalCase(name) {
+	return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/** Convert PascalCase to camelCase: `OrgProfile` → `orgProfile`. */
+function toCamelCase(pascalName) {
+	return pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
+}
+//#endregion
+//#region src/cli/commands/generate/project-config.ts
+/**
+* Read the host project's `.arcrc` (written at scaffold time by `arc init`)
+* and detect whether it's a TypeScript project via the presence of
+* `tsconfig.json`. Both checks degrade gracefully — a missing `.arcrc`
+* just means defaults, and the TS check uses the file marker rather than
+* inspecting `package.json` because the marker is what `tsx` / `tsc` also
+* key off.
+*/
+function readProjectConfig() {
+	try {
+		const rcPath = join(process.cwd(), ".arcrc");
+		return JSON.parse(readFileSync(rcPath, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+function isTypeScriptProject() {
+	return existsSync(join(process.cwd(), "tsconfig.json"));
+}
+//#endregion
+//#region src/cli/commands/generate/file-writer.ts
+/**
+* Scaffolding I/O for `arc generate`.
+*
+* Templates are pure (see `./templates.ts`); this module owns every
+* disk-touching step:
+*
+*   - `generateResource` writes the full resource folder
+*     (`<name>.model.ts` + `.repository.ts` + `.resource.ts` + optional
+*     `.mcp.ts`) plus the companion test file.
+*   - `generateFile` writes a single file (`controller` / `model` /
+*     `repository` / `schemas` / `mcp`).
+*
+* Both functions skip existing files with a clear console warning
+* (idempotent re-runs are safe) and use `node:fs` sync APIs — the CLI
+* is already synchronous in spirit and `Promise.all` parallelism on
+* file writes is not worth the readability tax.
+*/
+async function generateResource(name, lowerName, resourcePath, templates, ext, includeMcp = false) {
+	console.log(`\nGenerating resource: ${name}...\n`);
+	if (!existsSync(resourcePath)) {
+		mkdirSync(resourcePath, { recursive: true });
+		console.log(`  + Created: src/resources/${lowerName}/`);
+	}
+	const files = {
+		[`${lowerName}.model.${ext}`]: templates.model(name, lowerName),
+		[`${lowerName}.repository.${ext}`]: templates.repository(name, lowerName),
+		[`${lowerName}.resource.${ext}`]: templates.resource(name, lowerName)
+	};
+	if (includeMcp) files[`${lowerName}.mcp.${ext}`] = templates.mcp(name, lowerName);
+	for (const [filename, content] of Object.entries(files)) {
+		const filepath = join(resourcePath, filename);
+		if (existsSync(filepath)) console.warn(`  ! Skipped: ${filename} (already exists)`);
+		else {
+			writeFileSync(filepath, content);
+			console.log(`  + Created: ${filename}`);
+		}
+	}
+	const testsDir = join(process.cwd(), "tests");
+	if (!existsSync(testsDir)) mkdirSync(testsDir, { recursive: true });
+	const testPath = join(testsDir, `${lowerName}.test.${ext}`);
+	if (!existsSync(testPath)) {
+		writeFileSync(testPath, templates.test(name, lowerName));
+		console.log(`  + Created: tests/${lowerName}.test.${ext}`);
+	}
+	const camel = toCamelCase(name);
+	const isMultiTenant = readProjectConfig().tenant === "multi";
+	console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                    Resource Generated                         ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Next steps:
+
+1. Register in src/resources/index.${ext}:
+   import ${camel}Resource from './${lowerName}/${lowerName}.resource.js';
+
+   export const resources = [
+     // ... existing resources
+     ${camel}Resource,
+   ];
+
+2. Customize the model schema in:
+   src/resources/${lowerName}/${lowerName}.model.${ext}
+
+3. Adjust permissions in ${lowerName}.resource.${ext}:
+${isMultiTenant ? `   - requireOrgMembership() → member of the current organization
+   - multiTenantPreset()    → injects and filters organizationId
+   - requireRoles(['admin']) → admin writes inside the org scope` : `   - requireAuth()          → any authenticated user
+   - requireRoles(['admin']) → specific platform roles`}
+
+4. Run tests:
+   npm test
+${includeMcp ? `
+5. MCP tools file created: ${lowerName}.mcp.${ext}
+   Uncomment and customize the example tools.
+   Import and add to extraTools in your mcpPlugin config.
+` : ""}`);
+}
+async function generateFile(name, lowerName, resourcePath, fileType, template, ext) {
+	console.log(`\nGenerating ${fileType}: ${name}...\n`);
+	if (!existsSync(resourcePath)) {
+		mkdirSync(resourcePath, { recursive: true });
+		console.log(`  + Created: src/resources/${lowerName}/`);
+	}
+	const filename = `${lowerName}.${fileType}.${ext}`;
+	const filepath = join(resourcePath, filename);
+	if (existsSync(filepath)) throw new Error(`${filename} already exists. Remove it first or use a different name.`);
+	writeFileSync(filepath, template(name, lowerName));
+	console.log(`  + Created: ${filename}`);
+}
+//#endregion
+//#region src/cli/commands/generate/templates.ts
+/**
+* Template factory for `arc generate`.
+*
+* `getTemplates(ts, config)` returns a record of per-file template
+* functions. Each closure captures the language flag (`ts`) and project
+* config (multi-tenant, adapter, etc.) so call sites only need to pass
+* the resource-specific `name` / `fileName`. Templates remain pure —
+* no I/O, so the scaffolder's file-writer is the only spot that touches
+* disk.
+*
+* Templates included:
+*   - `model`       Mongoose schema with optional tenant field + index
+*   - `repository`  MongoKit-backed repo (or custom-adapter stub)
+*   - `controller`  BaseController extension scaffold
+*   - `schemas`     `buildCrudSchemasFromModel` with the field-rule menu
+*   - `resource`    `defineResource` wiring — branches on multi-tenant
+*   - `mcp`         Custom MCP tool examples (defineTool + zod schemas)
+*   - `test`        Vitest spec using `createTestApp` + `expectArc`
+*/
+/**
+* Template functions accept:
+* - `name`: PascalCase class name (e.g. `OrgProfile`)
+* - `fileName`: kebab-case for file paths (e.g. `org-profile`)
+*/
+function getTemplates(ts, config = {}) {
+	const isMultiTenant = config.tenant === "multi";
+	return {
+		model: (name, _fileName) => {
+			const camel = toCamelCase(name);
+			return `/**
+ * ${name} Model
+ * Generated by Arc CLI
+ */
+
+${ts ? "import mongoose, { type HydratedDocument, type Model, type Types } from 'mongoose';" : "import mongoose from 'mongoose';"}
+
+const { Schema } = mongoose;
+${ts ? [
+				"",
+				"/**",
+				" * Persisted shape — what `.lean()` and `.toObject()` return. Carrying this",
+				` * through \`Model<I${name}>\` lets \`.select(...)\` / \`.find(...)\` / \`.lean()\``,
+				" * infer correctly so domain methods don't need `as` casts.",
+				" *",
+				" * Replace the placeholder fields with your real domain shape.",
+				" */",
+				`export interface I${name} {`,
+				"  _id: Types.ObjectId;",
+				...isMultiTenant ? ["  organizationId: Types.ObjectId;"] : [],
+				"  // TODO: define your fields here",
+				"  createdAt: Date;",
+				"  updatedAt: Date;",
+				"}",
+				"",
+				`export type ${name}Document = HydratedDocument<I${name}>;`,
+				""
+			].join("\n") : ""}
+const ${camel}Schema = new Schema${ts ? `<I${name}>` : ""}(
+  {
+${isMultiTenant ? "    organizationId: { type: Schema.Types.ObjectId, required: true, index: true },\n" : ""}    // TODO: declare your fields here, e.g. name: { type: String, required: true, trim: true },
+  },
+  { timestamps: true }
+);
+
+${isMultiTenant ? `${camel}Schema.index({ organizationId: 1, createdAt: -1 });\n` : ""}${ts ? [
+				`const ${name}: Model<I${name}> =`,
+				`  (mongoose.models.${name} as Model<I${name}> | undefined) ??`,
+				`  mongoose.model<I${name}>('${name}', ${camel}Schema);`
+			].join("\n") : `const ${name} = mongoose.models.${name} || mongoose.model('${name}', ${camel}Schema);`}
+
+export default ${name};
+`;
+		},
+		repository: (name, fileName) => {
+			const camel = toCamelCase(name);
+			if (!(config.adapter === "mongokit" || !config.adapter)) {
+				const generic = ts ? `<I${name}>` : "";
+				return `/**
+ * ${name} Repository
+ * Generated by Arc CLI
+ *
+ * This project uses a custom adapter — wire your repository to whichever
+ * kit you're using (sqlitekit, prismakit, custom). Replace the body below
+ * with your kit's Repository constructor. Arc only requires the
+ * \`MinimalRepo\` floor (getAll/getById/create/update/delete) declared in
+ * \`@classytic/repo-core/repository\`.
+ */
+${ts ? `\nimport type { I${name} } from './${fileName}.model.js';` : ""}
+
+// Replace with your kit's repository instance:
+//   import { Repository } from '@classytic/sqlitekit';
+//   const ${camel}Repository = new Repository${generic}(${name}Table);
+//   export default ${camel}Repository;
+
+const ${camel}Repository = {
+  // TODO: implement MinimalRepo<${ts ? `I${name}` : "any"}>
+} as never;
+
+export default ${camel}Repository;
+`;
+			}
+			const generic = ts ? `<I${name}>` : "";
+			return `/**
+ * ${name} Repository
+ * Generated by Arc CLI
+ */
+
+import {
+  Repository,
+  methodRegistryPlugin,
+  softDeletePlugin,
+} from '@classytic/mongokit';
+import ${name} from './${fileName}.model.js';${ts ? `\nimport type { I${name} } from './${fileName}.model.js';` : ""}
+
+class ${name}Repository extends Repository${generic} {
+  constructor() {
+    super(${name}, [methodRegistryPlugin(), softDeletePlugin()]);
+  }
+
+  // Add domain methods here. arc + mongokit ship the standard CRUD
+  // (getAll/getById/create/update/delete) on the base class, so only
+  // write a method when there's real domain logic to capture.
+}
+
+const ${camel}Repository = new ${name}Repository();
+export default ${camel}Repository;
+export { ${name}Repository };
+`;
+		},
+		controller: (name, fileName) => {
+			const camel = toCamelCase(name);
+			return `/**
+ * ${name} Controller
+ * Generated by Arc CLI
+ *
+ * Note: defineResource() auto-creates a controller from the adapter.
+ * Only create a custom controller when you need custom methods.
+ */
+
+import { BaseController } from '@classytic/arc';
+import ${camel}Repository from './${fileName}.repository.js';
+
+class ${name}Controller extends BaseController {
+  constructor() {
+    super(${camel}Repository, {
+      resourceName: '${fileName}',
+    });
+  }
+
+  // Add custom controller methods here
+}
+
+const ${camel}Controller = new ${name}Controller();
+export default ${camel}Controller;
+`;
+		},
+		schemas: (name, fileName) => `/**
+ * ${name} Schemas
+ * Generated by Arc CLI
+ */
+
+import ${name} from './${fileName}.model.js';
+import { buildCrudSchemasFromModel } from '@classytic/mongokit';
+
+/**
+ * CRUD Schemas with Field Rules
+ */
+const crudSchemas = buildCrudSchemasFromModel(${name}, {
+  strictAdditionalProperties: true,
+  fieldRules: {
+    // systemManaged: framework stamps it — strip from body + required[]
+    // deletedAt: { systemManaged: true },
+    // immutable: cannot be updated after creation
+    // slug: { immutable: true },
+    // immutableAfterCreate: alias for immutable
+    // organizationId: { immutableAfterCreate: true },
+    // optional: removed from required[] (properties kept)
+    // description: { optional: true },
+    // nullable: widen JSON-Schema type to accept null (Zod .nullable() rescue)
+    // priceMode: { nullable: true },
+    // preserveForElevated: elevated admins keep the field on ingest (cross-tenant writes)
+    // organizationId: { systemManaged: true, preserveForElevated: true },
+  },
+  query: {
+    // Add your filterable fields here. createdAt is the default so the
+    // generated routes accept ?createdAt[gte]=2026-01-01 with no extra
+    // wiring. Add domain fields below as your model grows.
+    filterableFields: {
+      createdAt: 'date',
+    },
+  },
+});
+
+export default crudSchemas;
+`,
+		resource: (name, fileName) => {
+			const camel = toCamelCase(name);
+			const useMongoKit = config.adapter === "mongokit" || !config.adapter;
+			const schemaGeneratorImport = useMongoKit ? `import { buildCrudSchemasFromModel } from '@classytic/mongokit';\n` : "";
+			const queryParserImport = useMongoKit ? `\nimport { QueryParser } from '@classytic/mongokit';\n\nconst queryParser = new QueryParser({\n  // Whitelist the fields this resource accepts in URL filters.\n  // Empty by default — only \`createdAt\` is implicit; add yours.\n  allowedFilterFields: [],\n});\n` : "";
+			const adapterCall = useMongoKit ? `createMongooseAdapter({ model: ${name}, repository: ${camel}Repository, schemaGenerator: buildCrudSchemasFromModel })` : `createMongooseAdapter({ model: ${name}, repository: ${camel}Repository })`;
+			const queryParserConfig = useMongoKit ? `\n  queryParser,` : "";
+			return isMultiTenant ? `/**
+ * ${name} Resource
+ * Generated by Arc CLI
+ */
+
+import { defineResource } from '@classytic/arc';
+import { createMongooseAdapter } from '@classytic/mongokit/adapter';
+import { allOf, requireOrgMembership, requireRoles } from '@classytic/arc/permissions';
+import { multiTenantPreset } from '@classytic/arc/presets';
+${schemaGeneratorImport}import ${name}${ts ? `, { type I${name} }` : ""} from './${fileName}.model.js';
+import ${camel}Repository from './${fileName}.repository.js';${queryParserImport}
+
+const ${camel}Resource = defineResource${ts ? `<I${name}>` : ""}({
+  name: '${fileName}',
+  adapter: ${adapterCall},${queryParserConfig}
+
+  // Multi-tenant default: scope reads/writes by \`organizationId\`. For
+  // company-wide tables (lookup data, platform settings) set
+  // \`tenantField: false\` instead — otherwise queries silently return
+  // nothing because the column doesn't exist.
+  //
+  // Multi-level tenancy (org + branch + project, etc.) — replace with:
+  //   multiTenantPreset({ tenantFields: [
+  //     { field: 'organizationId', type: 'org' },
+  //     { field: 'branchId', contextKey: 'branchId' },
+  //   ] })
+  presets: ['softDelete', multiTenantPreset({ tenantField: 'organizationId' })],
+
+  // Tenant-cleanup strategy. Runs when an organization is deleted —
+  // wire \`cascadeDeleteForOrganization(arc.registry, { organizationId })\`
+  // into your auth lifecycle (Better Auth's afterDeleteOrganization,
+  // billing webhook, etc.) and every flagged resource is cleaned in one
+  // pass. Strategies: 'hard' (delete), 'soft' (deletedAt), 'anonymize'
+  // (clear PII, keep row — for legal-retained ledgers), 'skip' (no-op
+  // with mandatory reason). See arc/docs/compliance/tenant-cleanup.md.
+  onTenantDelete: { strategy: { type: 'hard' } },
+
+  // 2.16 — declarative CRUD allow-list (positive form). Uncomment to
+  // restrict the surface; a future arc CRUD op won't silently leak in
+  // because every op is opt-in. Mutually exclusive with \`disabledRoutes\`.
+  //   crud: { list: true, get: true },
+
+  permissions: {
+    list: requireOrgMembership(),
+    get: requireOrgMembership(),
+    create: allOf(requireOrgMembership(), requireRoles(['admin'])),
+    update: allOf(requireOrgMembership(), requireRoles(['admin'])),
+    delete: allOf(requireOrgMembership(), requireRoles(['admin'])),
+  },
+
+  // 2.16 — typed state-transition actions. \`defineAction()\` captures the
+  // schema's literal type so \`data\` is inferred — no \`as MyShape\` casts.
+  // Set \`id: false\` for resource-root actions (propose / search / bulk).
+  //
+  //   import { defineAction } from '@classytic/arc';
+  //   import { z } from 'zod';
+  //
+  //   actions: {
+  //     approve: defineAction({
+  //       schema: z.object({ reviewedBy: z.string() }),
+  //       permissions: requireRoles(['admin']),
+  //       handler: async (id, data) => { /* data.reviewedBy is typed */ },
+  //     }),
+  //   },
+});
+
+export default ${camel}Resource;
+` : `/**
+ * ${name} Resource
+ * Generated by Arc CLI
+ */
+
+import { defineResource } from '@classytic/arc';
+import { createMongooseAdapter } from '@classytic/mongokit/adapter';
+import { requireAuth, requireRoles } from '@classytic/arc/permissions';
+${schemaGeneratorImport}import ${name}${ts ? `, { type I${name} }` : ""} from './${fileName}.model.js';
+import ${camel}Repository from './${fileName}.repository.js';${queryParserImport}
+
+const ${camel}Resource = defineResource${ts ? `<I${name}>` : ""}({
+  name: '${fileName}',
+  adapter: ${adapterCall},${queryParserConfig}
+
+  // Single-tenant default: arc auto-infers \`tenantField: false\` when
+  // the model has no \`organizationId\` path (silent-zero-results
+  // footgun closed in 2.12). Set \`tenantField: '<field>'\` to opt INTO
+  // tenant scoping, or \`tenantField: false\` to make it explicit.
+  presets: ['softDelete'],
+
+  // 2.16 — declarative CRUD allow-list (positive form). Uncomment to
+  // restrict the surface; a future arc CRUD op won't silently leak in
+  // because every op is opt-in. Mutually exclusive with \`disabledRoutes\`.
+  //   crud: { list: true, get: true },
+
+  permissions: {
+    list: requireAuth(),
+    get: requireAuth(),
+    create: requireRoles(['admin']),
+    update: requireRoles(['admin']),
+    delete: requireRoles(['admin']),
+  },
+
+  // 2.16 — typed state-transition actions. \`defineAction()\` captures the
+  // schema's literal type so \`data\` is inferred. Set \`id: false\` for
+  // resource-root actions (propose / search / bulk).
+  //
+  //   import { defineAction } from '@classytic/arc';
+  //   import { z } from 'zod';
+  //
+  //   actions: {
+  //     publish: defineAction({
+  //       schema: z.object({ scheduledFor: z.string().datetime().optional() }),
+  //       permissions: requireRoles(['admin']),
+  //       handler: async (id, data) => { /* data.scheduledFor is typed */ },
+  //     }),
+  //   },
+});
+
+export default ${camel}Resource;
+`;
+		},
+		mcp: (name, fileName) => {
+			const camel = toCamelCase(name);
+			return `/**
+ * ${name} MCP Tools
+ * Generated by Arc CLI
+ *
+ * Custom MCP tools for the ${name} domain.
+ * CRUD tools (list/get/create/update/delete) are auto-generated by mcpPlugin.
+ * Add domain-specific tools here (actions, analytics, workflows).
+ */
+
+import { defineTool } from '@classytic/arc/mcp';
+${ts ? "import { z } from 'zod';\n" : "const { z } = require('zod');\n"}
+// Example: domain-specific action tool
+// export const activate${name}Tool = defineTool('activate_${fileName}', {
+//   description: 'Activate a ${name.toLowerCase()} by ID',
+//   input: { id: z.string().describe('${name} ID') },
+//   annotations: { destructiveHint: true, idempotentHint: true },
+//   handler: async ({ id }, ctx) => {
+//     // Your logic here
+//     return { content: [{ type: 'text', text: \`Activated ${name.toLowerCase()} \${id}\` }] };
+//   },
+// });
+
+// Example: read-only analytics tool
+// export const ${camel}StatsTool = defineTool('${fileName}_stats', {
+//   description: 'Get ${name.toLowerCase()} statistics',
+//   input: { period: z.enum(['7d', '30d', '90d']).optional() },
+//   annotations: { readOnlyHint: true },
+//   handler: async ({ period }) => {
+//     // Your logic here
+//     return { content: [{ type: 'text', text: JSON.stringify({ total: 0, period }) }] };
+//   },
+// });
+`;
+		},
+		test: (name, fileName) => {
+			const camel = toCamelCase(name);
+			return `/**
+ * ${name} Tests
+ * Generated by Arc CLI
+ *
+ * Testing surface (arc 2.12+):
+ *   - createTestApp   turnkey Fastify + in-memory Mongo + auth + fixtures
+ *   - expectArc       fluent matchers — .ok / .failed / .unauthorized /
+ *                     .forbidden / .notFound / .conflict / .validationError /
+ *                     .paginated / .hidesField / .hasData / .hasStatus
+ *   - ctx.auth        unified TestAuthProvider — register a role, reuse .headers
+ *
+ * Wire shape (post-2.12): single-doc responses are flat (\`{_id, name, ...}\`),
+ * paginated responses are \`{ method: 'offset', data: [...], page, ... }\`.
+ * No \`success\` envelope — HTTP status discriminates success vs error;
+ * errors carry the canonical ErrorContract \`{ code, message, status }\`.
+ */
+
+import { describe, it, beforeAll, afterAll, expect } from 'vitest';
+import { createTestApp, expectArc } from '@classytic/arc/testing';
+import type { TestAppContext } from '@classytic/arc/testing';
+import ${camel}Resource from '../src/resources/${fileName}/${fileName}.resource.js';
+
+describe('${name} Resource', () => {
+  let ctx${ts ? ": TestAppContext" : ""};
+
+  beforeAll(async () => {
+    ctx = await createTestApp({
+      resources: [${camel}Resource],
+      authMode: 'jwt',
+      connectMongoose: true,
+    });
+
+    ctx.auth${ts ? "!" : ""}.register('admin', {
+      user: { id: '1', roles: ['admin'] },
+      orgId: 'org-1',
+    });
+  });
+
+  afterAll(() => ctx.close());
+
+  describe('GET /${pluralize(fileName)}', () => {
+    it('returns a paginated list', async () => {
+      const res = await ctx.app.inject({
+        method: 'GET',
+        url: '/${pluralize(fileName)}',
+        headers: ctx.auth${ts ? "!" : ""}.as('admin').headers,
+      });
+      expectArc(res).ok().paginated();
+    });
+
+    it('rejects unauthenticated requests', async () => {
+      const res = await ctx.app.inject({ method: 'GET', url: '/${pluralize(fileName)}' });
+      expectArc(res).unauthorized();
+    });
+  });
+
+  describe('POST /${pluralize(fileName)}', () => {
+    it('creates a record (flat wire shape — no envelope)', async () => {
+      const res = await ctx.app.inject({
+        method: 'POST',
+        url: '/${pluralize(fileName)}',
+        headers: ctx.auth${ts ? "!" : ""}.as('admin').headers,
+        payload: { name: 'Example' },
+      });
+      expectArc(res).ok(201);
+      // Single-doc response is flat: \`body._id\` (not \`body.data._id\`).
+      const body = res.json()${ts ? " as { _id: string; name: string }" : ""};
+      expect(body._id).toBeDefined();
+      expect(body.name).toBe('Example');
+    });
+  });
+
+  // More patterns to extend:
+  //   - expectArc(res).forbidden() / .notFound() / .validationError()
+  //   - expectArc(res).hidesField('password') for field-level perms
+  //   - ctx.fixtures.create('${fileName}', {...}) for seeded data
+  //   - error wire shape: body.code === 'arc.not_found' (ErrorContract)
+});
+`;
+		}
+	};
+}
+//#endregion
+//#region src/cli/commands/generate/index.ts
+/**
+* `arc generate` orchestrator.
+*
+* Routes the user-supplied type (`resource` / `controller` / `model` /
+* `repository` / `schemas` / `mcp`, plus their short aliases) into the
+* matching file-writer call. The orchestrator owns:
+*
+*   - Name normalisation (kebab-case → PascalCase, kebab stays as the
+*     filename root).
+*   - The Better Auth-owned collection guard — refusing to generate a
+*     model named `user` / `organization` / etc. since BA writes those
+*     itself and a duplicate Mongoose registration silently collides.
+*   - Project-config detection (`.arcrc` + `tsconfig.json`) to pick the
+*     right template set + extension.
+*
+* Every step downstream is pure (templates) or local I/O (file-writer);
+* no network, no DB, no global state.
+*/
+async function generate(type, args) {
+	if (!type) throw new Error("Missing type argument\nUsage: arc generate <resource|controller|model|repository|schemas> <name>");
+	const [name, ...restArgs] = args;
+	if (!name) throw new Error("Missing name argument\nUsage: arc generate <type> <name>\nExample: arc generate resource product");
+	const capitalizedName = toPascalCase(name);
+	const lowerName = name.toLowerCase();
+	if ((type === "resource" || type === "r" || type === "model" || type === "m") && new Set([
+		"user",
+		"session",
+		"account",
+		"verification",
+		"organization",
+		"member",
+		"invitation",
+		"team",
+		"team-member",
+		"apikey"
+	]).has(lowerName)) {
+		console.warn(`\n[arc generate] "${lowerName}" is a Better Auth-owned collection.\nBetter Auth's organization/admin/bearer plugins write this collection directly,\nso generating a parallel arc model would create a duplicate registration.\n\nRecommended pattern:\n  import { createBetterAuthOverlay } from '@classytic/mongokit/better-auth';\n  const adapter = await createBetterAuthOverlay({\n    auth, mongoose, collection: '${lowerName}',\n  });\n  // ...then \`defineResource({ name: '${lowerName}', adapter, ... })\` reads\n  //    BA's collection through arc with full pagination/filters/permissions.\n\nAborting. Re-run with a different name if you need a separate domain model.\n`);
+		return;
+	}
+	const projectConfig = readProjectConfig();
+	const ts = projectConfig.typescript ?? isTypeScriptProject();
+	const ext = ts ? "ts" : "js";
+	const templates = getTemplates(ts, projectConfig);
+	const resourcePath = join(process.cwd(), "src", "resources", lowerName);
+	switch (type) {
+		case "resource":
+		case "r":
+			await generateResource(capitalizedName, lowerName, resourcePath, templates, ext, projectConfig.mcp === true || restArgs.includes("--mcp"));
+			break;
+		case "controller":
+		case "c":
+			await generateFile(capitalizedName, lowerName, resourcePath, "controller", templates.controller, ext);
+			break;
+		case "model":
+		case "m":
+			await generateFile(capitalizedName, lowerName, resourcePath, "model", templates.model, ext);
+			break;
+		case "repository":
+		case "repo":
+			await generateFile(capitalizedName, lowerName, resourcePath, "repository", templates.repository, ext);
+			break;
+		case "schemas":
+		case "s":
+			await generateFile(capitalizedName, lowerName, resourcePath, "schemas", templates.schemas, ext);
+			break;
+		case "mcp":
+			await generateFile(capitalizedName, lowerName, resourcePath, "mcp", templates.mcp, ext);
+			break;
+		default: throw new Error(`Unknown type: ${type}\nAvailable types: resource, controller, model, repository, schemas, mcp`);
+	}
+}
+//#endregion
+export { generate as t };

package/dist/hooks/index.d.mts

@@ -1,2 +1,2 @@
-import { An as afterCreate, Cn as HookContext, Dn as HookRegistration, En as HookPhase, Fn as beforeUpdate, In as createHookSystem, Ln as defineHook, Mn as afterUpdate, Nn as beforeCreate, On as HookSystem, Pn as beforeDelete, Sn as DefineHookOptions, Tn as HookOperation, jn as afterDelete, kn as HookSystemOptions, wn as HookHandler } from "../index-BswOSJCE.mjs";
+import { An as HookSystem, Dn as HookOperation, En as HookHandler, Fn as beforeCreate, In as beforeDelete, Ln as beforeUpdate, Mn as afterCreate, Nn as afterDelete, On as HookPhase, Pn as afterUpdate, Rn as createHookSystem, Tn as HookContext, jn as HookSystemOptions, kn as HookRegistration, wn as DefineHookOptions, zn as defineHook } from "../index-CkW0flkU.mjs";
 export { type DefineHookOptions, type HookContext, type HookHandler, type HookOperation, type HookPhase, type HookRegistration, HookSystem, type HookSystemOptions, afterCreate, afterDelete, afterUpdate, beforeCreate, beforeDelete, beforeUpdate, createHookSystem, defineHook };

package/dist/hooks/index.mjs

@@ -1,2 +1,2 @@
-import { a as beforeCreate, c as createHookSystem, i as afterUpdate, l as defineHook, n as afterCreate, o as beforeDelete, r as afterDelete, s as beforeUpdate, t as HookSystem } from "../HookSystem-Iiebom92.mjs";
+import { a as beforeCreate, c as createHookSystem, i as afterUpdate, l as defineHook, n as afterCreate, o as beforeDelete, r as afterDelete, s as beforeUpdate, t as HookSystem } from "../HookSystem-Cmf7-Etp.mjs";
 export { HookSystem, afterCreate, afterDelete, afterUpdate, beforeCreate, beforeDelete, beforeUpdate, createHookSystem, defineHook };

package/dist/idempotency/index.d.mts

@@ -1,5 +1,5 @@
-import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-DfLGcus7.mjs";
-import { i as RedisIdempotencyStoreOptions, n as RedisClient } from "../redis-DiMkdHEl.mjs";
+import { i as createIdempotencyResult, n as IdempotencyResult, r as IdempotencyStore, t as IdempotencyLock } from "../interface-NwJ_qPlY.mjs";
+import { i as RedisIdempotencyStoreOptions, n as RedisClient } from "../redis-Cyzrz6SX.mjs";
 import { FastifyPluginAsync } from "fastify";
 import { RepositoryLike } from "@classytic/repo-core/adapter";
 

package/dist/idempotency/index.mjs

@@ -1,4 +1,4 @@
-import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-BkIN9-vu.mjs";
+import { n as createSafeGetOne, t as createIsDuplicateKeyError } from "../store-helpers-B0sunfZZ.mjs";
 import { createHash } from "node:crypto";
 import fp from "fastify-plugin";
 import { and, eq, exists, gt, lt, or, startsWith } from "@classytic/repo-core/filter";