@classytic/arc 1.0.0

package/dist/cli/commands/introspect.js

@@ -0,0 +1,338 @@
+import fp from 'fastify-plugin';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/registry/ResourceRegistry.ts
+var ResourceRegistry, registryKey, globalScope, resourceRegistry;
+var init_ResourceRegistry = __esm({
+  "src/registry/ResourceRegistry.ts"() {
+    ResourceRegistry = class {
+      _resources;
+      _frozen;
+      constructor() {
+        this._resources = /* @__PURE__ */ new Map();
+        this._frozen = false;
+      }
+      /**
+       * Register a resource
+       */
+      register(resource, options = {}) {
+        if (this._frozen) {
+          throw new Error(
+            `Registry frozen. Cannot register '${resource.name}' after startup.`
+          );
+        }
+        if (this._resources.has(resource.name)) {
+          throw new Error(`Resource '${resource.name}' already registered.`);
+        }
+        const entry = {
+          name: resource.name,
+          displayName: resource.displayName,
+          tag: resource.tag,
+          prefix: resource.prefix,
+          module: options.module ?? void 0,
+          adapter: resource.adapter ? {
+            type: resource.adapter.type,
+            name: resource.adapter.name
+          } : null,
+          permissions: resource.permissions,
+          presets: resource._appliedPresets ?? [],
+          routes: [],
+          // Populated later by getIntrospection()
+          additionalRoutes: resource.additionalRoutes.map((r) => ({
+            method: r.method,
+            path: r.path,
+            handler: typeof r.handler === "string" ? r.handler : r.handler.name || "anonymous",
+            summary: r.summary,
+            description: r.description,
+            permissions: r.permissions,
+            wrapHandler: r.wrapHandler,
+            schema: r.schema
+            // Include schema for OpenAPI docs
+          })),
+          events: Object.keys(resource.events ?? {}),
+          registeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          disableDefaultRoutes: resource.disableDefaultRoutes,
+          openApiSchemas: options.openApiSchemas,
+          plugin: resource.toPlugin()
+          // Store plugin factory
+        };
+        this._resources.set(resource.name, entry);
+        return this;
+      }
+      /**
+       * Get resource by name
+       */
+      get(name) {
+        return this._resources.get(name);
+      }
+      /**
+       * Get all resources
+       */
+      getAll() {
+        return Array.from(this._resources.values());
+      }
+      /**
+       * Get resources by module
+       */
+      getByModule(moduleName) {
+        return this.getAll().filter((r) => r.module === moduleName);
+      }
+      /**
+       * Get resources by preset
+       */
+      getByPreset(presetName) {
+        return this.getAll().filter((r) => r.presets.includes(presetName));
+      }
+      /**
+       * Check if resource exists
+       */
+      has(name) {
+        return this._resources.has(name);
+      }
+      /**
+       * Get registry statistics
+       */
+      getStats() {
+        const resources = this.getAll();
+        const presetCounts = {};
+        for (const r of resources) {
+          for (const preset of r.presets) {
+            presetCounts[preset] = (presetCounts[preset] ?? 0) + 1;
+          }
+        }
+        return {
+          totalResources: resources.length,
+          byModule: this._groupBy(resources, "module"),
+          presetUsage: presetCounts,
+          totalRoutes: resources.reduce((sum, r) => {
+            const defaultRouteCount = r.disableDefaultRoutes ? 0 : 5;
+            return sum + (r.additionalRoutes?.length ?? 0) + defaultRouteCount;
+          }, 0),
+          totalEvents: resources.reduce((sum, r) => sum + (r.events?.length ?? 0), 0)
+        };
+      }
+      /**
+       * Get full introspection data
+       */
+      getIntrospection() {
+        return {
+          resources: this.getAll().map((r) => {
+            const defaultRoutes = r.disableDefaultRoutes ? [] : [
+              { method: "GET", path: r.prefix, operation: "list" },
+              { method: "GET", path: `${r.prefix}/:id`, operation: "get" },
+              { method: "POST", path: r.prefix, operation: "create" },
+              { method: "PATCH", path: `${r.prefix}/:id`, operation: "update" },
+              { method: "DELETE", path: `${r.prefix}/:id`, operation: "delete" }
+            ];
+            return {
+              name: r.name,
+              displayName: r.displayName,
+              prefix: r.prefix,
+              module: r.module,
+              presets: r.presets,
+              permissions: r.permissions,
+              routes: [
+                ...defaultRoutes,
+                ...r.additionalRoutes?.map((ar) => ({
+                  method: ar.method,
+                  path: `${r.prefix}${ar.path}`,
+                  operation: typeof ar.handler === "string" ? ar.handler : "custom",
+                  handler: typeof ar.handler === "string" ? ar.handler : void 0,
+                  summary: ar.summary
+                })) ?? []
+              ],
+              events: r.events
+            };
+          }),
+          stats: this.getStats(),
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      /**
+       * Freeze registry (prevent further registrations)
+       */
+      freeze() {
+        this._frozen = true;
+      }
+      /**
+       * Check if frozen
+       */
+      isFrozen() {
+        return this._frozen;
+      }
+      /**
+       * Unfreeze registry (for testing)
+       */
+      _unfreeze() {
+        this._frozen = false;
+      }
+      /**
+       * Clear all resources (for testing)
+       */
+      _clear() {
+        this._resources.clear();
+        this._frozen = false;
+      }
+      /**
+       * Group by key
+       */
+      _groupBy(arr, key) {
+        const result = {};
+        for (const item of arr) {
+          const k = String(item[key] ?? "uncategorized");
+          result[k] = (result[k] ?? 0) + 1;
+        }
+        return result;
+      }
+    };
+    registryKey = /* @__PURE__ */ Symbol.for("arc.resourceRegistry");
+    globalScope = globalThis;
+    resourceRegistry = globalScope[registryKey] ?? new ResourceRegistry();
+    if (!globalScope[registryKey]) {
+      globalScope[registryKey] = resourceRegistry;
+    }
+  }
+});
+var introspectionPlugin, introspectionPlugin_default;
+var init_introspectionPlugin = __esm({
+  "src/registry/introspectionPlugin.ts"() {
+    init_ResourceRegistry();
+    introspectionPlugin = async (fastify, opts = {}) => {
+      const {
+        prefix = "/_resources",
+        authRoles = ["superadmin"],
+        enabled = process.env.NODE_ENV !== "production" || process.env.ENABLE_INTROSPECTION === "true"
+      } = opts;
+      if (!enabled) {
+        fastify.log?.info?.("Introspection plugin disabled");
+        return;
+      }
+      const typedFastify = fastify;
+      const authMiddleware = authRoles.length > 0 && typedFastify.authenticate ? [
+        typedFastify.authenticate,
+        typedFastify.authorize?.(...authRoles)
+      ].filter(Boolean) : [];
+      await fastify.register(async (instance) => {
+        instance.get(
+          "/",
+          {
+            preHandler: authMiddleware
+          },
+          async (_req, _reply) => {
+            return resourceRegistry.getIntrospection();
+          }
+        );
+        instance.get(
+          "/stats",
+          {
+            preHandler: authMiddleware
+          },
+          async (_req, _reply) => {
+            return resourceRegistry.getStats();
+          }
+        );
+        instance.get(
+          "/:name",
+          {
+            schema: {
+              params: {
+                type: "object",
+                properties: {
+                  name: { type: "string" }
+                },
+                required: ["name"]
+              }
+            },
+            preHandler: authMiddleware
+          },
+          async (req, reply) => {
+            const resource = resourceRegistry.get(req.params.name);
+            if (!resource) {
+              return reply.code(404).send({
+                error: `Resource '${req.params.name}' not found`
+              });
+            }
+            return resource;
+          }
+        );
+      }, { prefix });
+      fastify.log?.info?.(`Introspection API at ${prefix}`);
+    };
+    introspectionPlugin_default = fp(introspectionPlugin, { name: "arc-introspection" });
+  }
+});
+
+// src/registry/index.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ResourceRegistry: () => ResourceRegistry,
+  introspectionPlugin: () => introspectionPlugin_default,
+  introspectionPluginFn: () => introspectionPlugin,
+  resourceRegistry: () => resourceRegistry
+});
+var init_registry = __esm({
+  "src/registry/index.ts"() {
+    init_ResourceRegistry();
+    init_introspectionPlugin();
+  }
+});
+
+// src/cli/commands/introspect.ts
+async function introspect(args) {
+  console.log("Introspecting Arc resources...\n");
+  try {
+    const { resourceRegistry: resourceRegistry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    const resources = resourceRegistry2.getAll();
+    if (resources.length === 0) {
+      console.log("⚠️  No resources registered.");
+      console.log("\nTo introspect resources, you need to load them first:");
+      console.log("  arc introspect --entry ./index.js");
+      console.log("\nWhere index.js imports all your resource definitions.");
+      return;
+    }
+    console.log(`Found ${resources.length} resource(s):
+`);
+    resources.forEach((resource, index) => {
+      console.log(`${index + 1}. ${resource.name}`);
+      console.log(`   Display Name: ${resource.displayName}`);
+      console.log(`   Prefix: ${resource.prefix}`);
+      console.log(`   Module: ${resource.module || "none"}`);
+      if (resource.permissions) {
+        console.log(`   Permissions:`);
+        Object.entries(resource.permissions).forEach(([op, roles]) => {
+          console.log(`     ${op}: [${roles.join(", ")}]`);
+        });
+      }
+      if (resource.presets && resource.presets.length > 0) {
+        console.log(`   Presets: ${resource.presets.join(", ")}`);
+      }
+      if (resource.additionalRoutes && resource.additionalRoutes.length > 0) {
+        console.log(`   Additional Routes: ${resource.additionalRoutes.length}`);
+      }
+      console.log("");
+    });
+    const stats = resourceRegistry2.getStats();
+    console.log("Summary:");
+    console.log(`  Total Resources: ${stats.totalResources}`);
+    console.log(`  With Presets: ${resources.filter((r) => r.presets?.length > 0).length}`);
+    console.log(
+      `  With Custom Routes: ${resources.filter((r) => r.additionalRoutes && r.additionalRoutes.length > 0).length}`
+    );
+  } catch (error) {
+    console.error("Error:", error.message);
+    console.log("\nTip: Run this command after starting your application.");
+    process.exit(1);
+  }
+}
+var introspect_default = introspect;
+
+export { introspect_default as default, introspect };

package/dist/cli/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * CLI Module - Programmatic API
+ *
+ * @example
+ * import { generate } from '@classytic/arc/cli';
+ *
+ * await generate('resource', 'product', {
+ *   module: 'catalog',
+ *   presets: ['softDelete', 'slugLookup'],
+ * });
+ */
+interface GenerateOptions {
+    module?: string;
+    presets?: string[];
+    parentField?: string;
+    withTests?: boolean;
+    dryRun?: boolean;
+    force?: boolean;
+    outputDir?: string;
+    /** Generate TypeScript (default: true) or JavaScript */
+    typescript?: boolean;
+}
+interface GeneratedFile {
+    name: string;
+    content: string;
+}
+interface GenerateResult {
+    files: GeneratedFile[];
+    dirPath: string;
+}
+/**
+ * Generate resource files
+ *
+ * @param type - 'resource', 'controller', or 'model'
+ * @param name - Resource name (e.g., 'product', 'order-item')
+ * @param options - Generation options
+ */
+declare function generate(type: string, name: string, options?: GenerateOptions): Promise<GenerateResult>;
+declare const _default: {
+    generate: typeof generate;
+};
+
+export { type GenerateOptions, type GenerateResult, type GeneratedFile, _default as default, generate };