@classytic/arc 1.1.0 → 2.1.3

package/dist/cli/commands/describe.d.mts

@@ -0,0 +1,18 @@
+//#region src/cli/commands/describe.d.ts
+/**
+ * Arc CLI - Describe Command
+ *
+ * Machine-readable resource metadata for AI agents.
+ * Outputs JSON with fields, permissions, pipeline, routes, events —
+ * everything an LLM needs to understand and generate code for the API.
+ *
+ * @example
+ * ```bash
+ * arc describe ./src/resources.js --json
+ * arc describe ./src/resources.js --resource product
+ * arc describe ./src/resources.js --pretty
+ * ```
+ */
+declare function describe(args: string[]): Promise<void>;
+//#endregion
+export { describe as default, describe };

package/dist/cli/commands/describe.mjs

@@ -0,0 +1,238 @@
+import { t as CRUD_OPERATIONS } from "../../constants-DdXFXQtN.mjs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+//#region src/cli/commands/describe.ts
+/**
+* Arc CLI - Describe Command
+*
+* Machine-readable resource metadata for AI agents.
+* Outputs JSON with fields, permissions, pipeline, routes, events —
+* everything an LLM needs to understand and generate code for the API.
+*
+* @example
+* ```bash
+* arc describe ./src/resources.js --json
+* arc describe ./src/resources.js --resource product
+* arc describe ./src/resources.js --pretty
+* ```
+*/
+function describePermission(check) {
+	if (!check || typeof check !== "function") return { type: "custom" };
+	const fn = check;
+	if (fn._isPublic === true) return { type: "public" };
+	if (Array.isArray(fn._roles)) return {
+		type: "requireRoles",
+		roles: fn._roles
+	};
+	const src = check.toString();
+	if (src.includes("ctx.user") && !src.includes("roles") && src.length < 200) return { type: "requireAuth" };
+	return { type: "custom" };
+}
+function describePermissions(perms) {
+	if (!perms) return {};
+	const result = {};
+	for (const op of CRUD_OPERATIONS) {
+		const check = perms[op];
+		if (check) result[op] = describePermission(check);
+	}
+	return result;
+}
+function describeFields(fieldPerms) {
+	if (!fieldPerms || Object.keys(fieldPerms).length === 0) return void 0;
+	const result = {};
+	for (const [field, perm] of Object.entries(fieldPerms)) {
+		const desc = { type: perm._type };
+		if (perm.roles?.length) desc.roles = perm.roles;
+		if (perm.redactValue !== void 0) desc.redactValue = perm.redactValue;
+		result[field] = desc;
+	}
+	return result;
+}
+function describePipeline(pipe) {
+	if (!pipe) return void 0;
+	const steps = [];
+	if (Array.isArray(pipe)) steps.push(...pipe);
+	else {
+		const seen = /* @__PURE__ */ new Set();
+		for (const opSteps of Object.values(pipe)) if (Array.isArray(opSteps)) for (const step of opSteps) {
+			const key = `${step._type}:${step.name}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				steps.push(step);
+			}
+		}
+	}
+	if (steps.length === 0) return void 0;
+	const guards = [];
+	const transforms = [];
+	const interceptors = [];
+	for (const step of steps) {
+		const desc = { name: step.name };
+		if (step.operations?.length) desc.operations = [...step.operations];
+		switch (step._type) {
+			case "guard":
+				guards.push(desc);
+				break;
+			case "transform":
+				transforms.push(desc);
+				break;
+			case "interceptor":
+				interceptors.push(desc);
+				break;
+		}
+	}
+	return {
+		guards,
+		transforms,
+		interceptors
+	};
+}
+function describeRoutes(resource) {
+	const routes = [];
+	if (!resource.disableDefaultRoutes) {
+		const disabled = new Set(resource.disabledRoutes ?? []);
+		for (const { method, suffix, op } of [
+			{
+				method: "GET",
+				suffix: "",
+				op: "list"
+			},
+			{
+				method: "GET",
+				suffix: "/:id",
+				op: "get"
+			},
+			{
+				method: "POST",
+				suffix: "",
+				op: "create"
+			},
+			{
+				method: "PATCH",
+				suffix: "/:id",
+				op: "update"
+			},
+			{
+				method: "DELETE",
+				suffix: "/:id",
+				op: "delete"
+			}
+		]) if (!disabled.has(op)) {
+			const route = {
+				method,
+				path: `${resource.prefix}${suffix}`,
+				operation: op
+			};
+			const perm = resource.permissions[op];
+			if (perm) route.permission = describePermission(perm);
+			routes.push(route);
+		}
+	}
+	for (const ar of resource.additionalRoutes) routes.push({
+		method: ar.method,
+		path: `${resource.prefix}${ar.path}`,
+		operation: typeof ar.handler === "string" ? ar.handler : "custom",
+		summary: ar.summary,
+		description: ar.description,
+		permission: describePermission(ar.permissions)
+	});
+	return routes;
+}
+function describeEvents(resourceName, events) {
+	if (!events) return [];
+	return Object.entries(events).map(([action, def]) => ({
+		name: `${resourceName}:${action}`,
+		description: def.description,
+		hasSchema: !!def.schema
+	}));
+}
+function describeMiddlewares(middlewares) {
+	if (!middlewares) return [];
+	const ops = [];
+	for (const [op, handlers] of Object.entries(middlewares)) if (handlers?.length) ops.push(`${op}(${handlers.length})`);
+	return ops;
+}
+function describeResource(resource, module) {
+	return {
+		name: resource.name,
+		displayName: resource.displayName,
+		prefix: resource.prefix,
+		tag: resource.tag,
+		module,
+		adapter: resource.adapter ? {
+			type: resource.adapter.type,
+			name: resource.adapter.name
+		} : null,
+		permissions: describePermissions(resource.permissions),
+		presets: resource._appliedPresets ?? [],
+		fields: describeFields(resource.fields),
+		pipeline: describePipeline(resource.pipe),
+		routes: describeRoutes(resource),
+		events: describeEvents(resource.name, resource.events),
+		schemaOptions: Object.keys(resource.schemaOptions ?? {}).length > 0 ? resource.schemaOptions : void 0,
+		rateLimit: resource.rateLimit,
+		middlewares: describeMiddlewares(resource.middlewares)
+	};
+}
+async function describe(args) {
+	try {
+		const flags = new Set(args.filter((a) => a.startsWith("--")));
+		const positional = args.filter((a) => !a.startsWith("--"));
+		const pretty = flags.has("--pretty") || !flags.has("--json");
+		const filterResource = positional[1];
+		const entryPath = positional[0];
+		if (!entryPath) {
+			console.log("Usage: arc describe <entry-file> [resource-name] [--json] [--pretty]\n");
+			console.log("Outputs machine-readable JSON metadata for AI agents.\n");
+			console.log("Options:");
+			console.log("  --json     Output compact JSON (default if piped)");
+			console.log("  --pretty   Output formatted JSON (default if terminal)");
+			console.log("\nExamples:");
+			console.log("  arc describe ./src/resources.js");
+			console.log("  arc describe ./src/resources.js product");
+			console.log("  arc describe ./src/resources.js --json | jq .");
+			return;
+		}
+		const entryModule = await import(pathToFileURL(resolve(process.cwd(), entryPath)).href);
+		const resources = [];
+		function tryCollect(value) {
+			if (value && typeof value === "object" && "name" in value && "_registryMeta" in value && "toPlugin" in value) resources.push(value);
+		}
+		for (const exported of Object.values(entryModule)) if (Array.isArray(exported)) exported.forEach(tryCollect);
+		else tryCollect(exported);
+		if (resources.length === 0) throw new Error("No resource definitions found in entry file.\nMake sure your file exports defineResource() results:\n  export const productResource = defineResource({ ... });");
+		const filtered = filterResource ? resources.filter((r) => r.name === filterResource) : resources;
+		if (filterResource && filtered.length === 0) throw new Error(`Resource '${filterResource}' not found.\nAvailable: ${resources.map((r) => r.name).join(", ")}`);
+		const described = filtered.map((r) => describeResource(r, r._registryMeta?.module));
+		const presetCounts = {};
+		let totalPipelineSteps = 0;
+		let totalFields = 0;
+		for (const res of described) {
+			for (const preset of res.presets) presetCounts[preset] = (presetCounts[preset] ?? 0) + 1;
+			if (res.pipeline) totalPipelineSteps += res.pipeline.guards.length + res.pipeline.transforms.length + res.pipeline.interceptors.length;
+			if (res.fields) totalFields += Object.keys(res.fields).length;
+		}
+		const output = {
+			$schema: "arc-describe/v1",
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			resources: described,
+			stats: {
+				totalResources: described.length,
+				totalRoutes: described.reduce((sum, r) => sum + r.routes.length, 0),
+				totalEvents: described.reduce((sum, r) => sum + r.events.length, 0),
+				totalFields,
+				presetUsage: presetCounts,
+				pipelineSteps: totalPipelineSteps
+			}
+		};
+		const json = pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+		console.log(json);
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(String(error));
+	}
+}
+
+//#endregion
+export { describe as default, describe };

package/dist/cli/commands/docs.d.mts

@@ -0,0 +1,13 @@
+//#region src/cli/commands/docs.d.ts
+/**
+ * Arc CLI - Docs Command
+ *
+ * Export OpenAPI specification from registered resources.
+ * Requires an entry file that exports defineResource() results.
+ */
+declare function exportDocs(args: string[]): Promise<void>;
+declare const _default: {
+  exportDocs: typeof exportDocs;
+};
+//#endregion
+export { _default as default, exportDocs };

package/dist/cli/commands/docs.mjs

@@ -0,0 +1,52 @@
+import { t as ResourceRegistry } from "../../ResourceRegistry-7Ic20ZMw.mjs";
+import { t as buildOpenApiSpec } from "../../openapi-9nB_kiuR.mjs";
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+//#region src/cli/commands/docs.ts
+/**
+* Arc CLI - Docs Command
+*
+* Export OpenAPI specification from registered resources.
+* Requires an entry file that exports defineResource() results.
+*/
+function parseDocsArgs(args) {
+	const outputPath = args.find((a) => a.endsWith(".json")) ?? "./openapi.json";
+	return {
+		entryPath: args.find((a) => !a.endsWith(".json")),
+		outputPath
+	};
+}
+async function exportDocs(args) {
+	const { entryPath, outputPath } = parseDocsArgs(args);
+	console.log("Exporting OpenAPI specification...\n");
+	if (!entryPath) throw new Error("Missing entry file.\n\nUsage: arc docs <entry-file> [output.json]\nExample: arc docs ./src/resources.js ./openapi.json");
+	const entryModule = await import(pathToFileURL(resolve(process.cwd(), entryPath)).href);
+	const registry = new ResourceRegistry();
+	let registered = 0;
+	function tryRegister(value) {
+		if (value && typeof value === "object" && "name" in value && "_registryMeta" in value && "toPlugin" in value) {
+			registry.register(value, value._registryMeta ?? {});
+			registered++;
+		}
+	}
+	for (const exported of Object.values(entryModule)) if (Array.isArray(exported)) exported.forEach(tryRegister);
+	else tryRegister(exported);
+	if (registered === 0) throw new Error("No resource definitions found in entry file.\nMake sure your file exports defineResource() results:\n  export const productResource = defineResource({ ... });");
+	const resources = registry.getAll();
+	const spec = buildOpenApiSpec(resources, {
+		title: "Arc API",
+		version: "1.0.0",
+		description: "Auto-generated from Arc resources"
+	});
+	const fullPath = resolve(process.cwd(), outputPath);
+	writeFileSync(fullPath, JSON.stringify(spec, null, 2));
+	console.log(`OpenAPI spec exported to: ${fullPath}`);
+	console.log(`\nResources included: ${resources.length}`);
+	console.log(`Total endpoints: ${Object.keys(spec.paths).length}`);
+}
+var docs_default = { exportDocs };
+
+//#endregion
+export { docs_default as default, exportDocs };

package/dist/cli/commands/{generate.d.ts → generate.d.mts}

@@ -1,3 +1,4 @@
+//#region src/cli/commands/generate.d.ts
 /**
  * Arc CLI - Generate Command
  *
@@ -12,5 +13,5 @@
  * Generate command handler
  */
 declare function generate(type: string | undefined, args: string[]): Promise<void>;
-
-export { generate as default, generate };
+//#endregion
+export { generate as default, generate };

package/dist/cli/commands/generate.mjs

@@ -0,0 +1,357 @@
+import { t as pluralize } from "../../pluralize-CM-jZg7p.mjs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/cli/commands/generate.ts
+/**
+* Arc CLI - Generate Command
+*
+* Scaffolds resources with consistent naming:
+* - src/resources/product/product.model.ts
+* - src/resources/product/product.repository.ts
+* - src/resources/product/product.resource.ts
+* - src/resources/product/product.controller.ts
+* - src/resources/product/product.schemas.ts
+*/
+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"));
+}
+function getTemplates(ts, config = {}) {
+	const isMultiTenant = config.tenant === "multi";
+	return {
+		model: (name) => `/**
+ * ${name} Model
+ * Generated by Arc CLI
+ */
+
+import mongoose${ts ? ", { type HydratedDocument }" : ""} from 'mongoose';
+
+const { Schema } = mongoose;
+${ts ? `
+export interface I${name} {
+  name: string;
+  description?: string;
+  isActive: boolean;
+}
+
+export type ${name}Document = HydratedDocument<I${name}>;
+` : ""}
+const ${name.toLowerCase()}Schema = new Schema${ts ? `<I${name}>` : ""}(
+  {
+    name: { type: String, required: true, trim: true },
+    description: { type: String, trim: true },
+    isActive: { type: Boolean, default: true },
+  },
+  { timestamps: true }
+);
+
+// Indexes
+${name.toLowerCase()}Schema.index({ name: 1 });
+${name.toLowerCase()}Schema.index({ isActive: 1 });
+
+const ${name} = mongoose.models.${name} || mongoose.model('${name}', ${name.toLowerCase()}Schema);
+export default ${name};
+`,
+		repository: (name) => `/**
+ * ${name} Repository
+ * Generated by Arc CLI
+ */
+
+import {
+  Repository,
+  methodRegistryPlugin,
+  softDeletePlugin,
+  mongoOperationsPlugin,
+} from '@classytic/mongokit';
+import ${name} from './${name.toLowerCase()}.model.js';
+
+class ${name}Repository extends Repository {
+  constructor() {
+    super(${name}, [
+      methodRegistryPlugin(),
+      softDeletePlugin(),
+      mongoOperationsPlugin(),
+    ]);
+  }
+
+  /**
+   * Find all active records
+   */
+  async findActive() {
+    return this.Model.find({ isActive: true, deletedAt: null }).lean();
+  }
+}
+
+const ${name.toLowerCase()}Repository = new ${name}Repository();
+export default ${name.toLowerCase()}Repository;
+export { ${name}Repository };
+`,
+		controller: (name) => `/**
+ * ${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 ${name.toLowerCase()}Repository from './${name.toLowerCase()}.repository.js';
+
+class ${name}Controller extends BaseController {
+  constructor() {
+    super(${name.toLowerCase()}Repository, {
+      resourceName: '${name.toLowerCase()}',
+    });
+  }
+
+  // Add custom controller methods here
+}
+
+const ${name.toLowerCase()}Controller = new ${name}Controller();
+export default ${name.toLowerCase()}Controller;
+`,
+		schemas: (name) => `/**
+ * ${name} Schemas
+ * Generated by Arc CLI
+ */
+
+import ${name} from './${name.toLowerCase()}.model.js';
+import { buildCrudSchemasFromModel } from '@classytic/mongokit/utils';
+
+/**
+ * CRUD Schemas with Field Rules
+ */
+const crudSchemas = buildCrudSchemasFromModel(${name}, {
+  strictAdditionalProperties: true,
+  fieldRules: {
+    // Mark fields as system-managed (excluded from create/update)
+    // deletedAt: { systemManaged: true },
+  },
+  query: {
+    filterableFields: {
+      isActive: 'boolean',
+      createdAt: 'date',
+    },
+  },
+});
+
+export default crudSchemas;
+`,
+		resource: (name) => {
+			const useMongoKit = config.adapter === "mongokit" || !config.adapter;
+			const queryParserImport = useMongoKit ? `\nimport { QueryParser } from '@classytic/mongokit';\n\nconst queryParser = new QueryParser();\n` : "";
+			const queryParserConfig = useMongoKit ? `\n  queryParser,` : "";
+			return isMultiTenant ? `/**
+ * ${name} Resource
+ * Generated by Arc CLI
+ */
+
+import { defineResource, createMongooseAdapter } from '@classytic/arc';
+import { requireOrgMembership, requireOrgRole } from '@classytic/arc/permissions';
+import ${name}${ts ? `, { type I${name} }` : ""} from './${name.toLowerCase()}.model.js';
+import ${name.toLowerCase()}Repository from './${name.toLowerCase()}.repository.js';${queryParserImport}
+
+const ${name.toLowerCase()}Resource = defineResource${ts ? `<I${name}>` : ""}({
+  name: '${name.toLowerCase()}',
+  adapter: createMongooseAdapter(${name}, ${name.toLowerCase()}Repository),${queryParserConfig}
+  presets: ['softDelete'],
+  permissions: {
+    list: requireOrgMembership(),
+    get: requireOrgMembership(),
+    create: requireOrgRole('admin'),
+    update: requireOrgRole('admin'),
+    delete: requireOrgRole('admin'),
+  },
+});
+
+export default ${name.toLowerCase()}Resource;
+` : `/**
+ * ${name} Resource
+ * Generated by Arc CLI
+ */
+
+import { defineResource, createMongooseAdapter } from '@classytic/arc';
+import { requireAuth, requireRoles } from '@classytic/arc/permissions';
+import ${name}${ts ? `, { type I${name} }` : ""} from './${name.toLowerCase()}.model.js';
+import ${name.toLowerCase()}Repository from './${name.toLowerCase()}.repository.js';${queryParserImport}
+
+const ${name.toLowerCase()}Resource = defineResource${ts ? `<I${name}>` : ""}({
+  name: '${name.toLowerCase()}',
+  adapter: createMongooseAdapter(${name}, ${name.toLowerCase()}Repository),${queryParserConfig}
+  presets: ['softDelete'],
+  permissions: {
+    list: requireAuth(),
+    get: requireAuth(),
+    create: requireRoles(['admin']),
+    update: requireRoles(['admin']),
+    delete: requireRoles(['admin']),
+  },
+});
+
+export default ${name.toLowerCase()}Resource;
+`;
+		},
+		test: (name) => `/**
+ * ${name} Tests
+ * Generated by Arc CLI
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import mongoose from 'mongoose';
+import { createMinimalTestApp } from '@classytic/arc/testing';
+${ts ? "import type { FastifyInstance } from 'fastify';\n" : ""}import ${name.toLowerCase()}Resource from '../src/resources/${name.toLowerCase()}/${name.toLowerCase()}.resource.js';
+
+describe('${name} Resource', () => {
+  let app${ts ? ": FastifyInstance" : ""};
+
+  beforeAll(async () => {
+    const testDbUri = process.env.MONGODB_URI || 'mongodb://localhost:27017/arc-app-test';
+    await mongoose.connect(testDbUri);
+
+    app = createMinimalTestApp();
+    await app.register(${name.toLowerCase()}Resource.toPlugin());
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await mongoose.connection.close();
+  });
+
+  describe('GET /${pluralize(name.toLowerCase())}', () => {
+    it('should return a list', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${pluralize(name.toLowerCase())}',
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body).toHaveProperty('docs');
+    });
+  });
+});
+`
+	};
+}
+/**
+* Generate command handler
+*/
+async function generate(type, args) {
+	if (!type) throw new Error("Missing type argument\nUsage: arc generate <resource|controller|model|repository|schemas> <name>");
+	const [name] = args;
+	if (!name) throw new Error("Missing name argument\nUsage: arc generate <type> <name>\nExample: arc generate resource product");
+	const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+	const lowerName = name.toLowerCase();
+	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);
+			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;
+		default: throw new Error(`Unknown type: ${type}\nAvailable types: resource, controller, model, repository, schemas`);
+	}
+}
+/**
+* Generate a full resource
+*/
+async function generateResource(name, lowerName, resourcePath, templates, ext) {
+	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}.repository.${ext}`]: templates.repository(name),
+		[`${lowerName}.resource.${ext}`]: templates.resource(name)
+	};
+	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));
+		console.log(`  + Created: tests/${lowerName}.test.${ext}`);
+	}
+	const isMultiTenant = readProjectConfig().tenant === "multi";
+	console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                    Resource Generated                         ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Next steps:
+
+1. Register in src/resources/index.${ext}:
+   import ${lowerName}Resource from './${lowerName}/${lowerName}.resource.js';
+
+   export const resources = [
+     // ... existing resources
+     ${lowerName}Resource,
+   ];
+
+2. Customize the model schema in:
+   src/resources/${lowerName}/${lowerName}.model.${ext}
+
+3. Adjust permissions in ${lowerName}.resource.${ext}:
+${isMultiTenant ? `   - requireOrgMembership()  → any org member
+   - requireOrgRole('admin') → specific org roles` : `   - requireAuth()          → any authenticated user
+   - requireRoles(['admin']) → specific platform roles`}
+
+4. Run tests:
+   npm test
+`);
+}
+/**
+* Generate a single file
+*/
+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));
+	console.log(`  + Created: ${filename}`);
+}
+
+//#endregion
+export { generate as default, generate };