@classytic/arc 1.0.0

package/dist/cli/commands/docs.js

@@ -0,0 +1,474 @@
+import fp from 'fastify-plugin';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+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();
+  }
+});
+async function exportDocs(args) {
+  const [outputPath = "./openapi.json"] = args;
+  console.log("Exporting OpenAPI specification...\n");
+  try {
+    const { resourceRegistry: resourceRegistry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    const resources = resourceRegistry2.getAll();
+    if (resources.length === 0) {
+      console.warn("⚠️  No resources registered.");
+      console.log("\nTo export docs, you need to load your resources first:");
+      console.log("  arc docs ./openapi.json --entry ./index.js");
+      console.log("\nWhere index.js imports all your resource definitions.");
+      process.exit(1);
+    }
+    const spec = {
+      openapi: "3.0.0",
+      info: {
+        title: "Arc API",
+        version: "1.0.0",
+        description: "Auto-generated from Arc resources"
+      },
+      servers: [
+        {
+          url: "http://localhost:8040/api/v1",
+          description: "Development server"
+        }
+      ],
+      paths: {},
+      components: {
+        schemas: {},
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            bearerFormat: "JWT"
+          }
+        }
+      }
+    };
+    resources.forEach((resource) => {
+      const basePath = resource.prefix || `/${resource.name}s`;
+      spec.paths[basePath] = {
+        get: {
+          tags: [resource.name],
+          summary: `List ${resource.name}s`,
+          security: resource.permissions?.list ? [{ bearerAuth: [] }] : [],
+          parameters: [
+            {
+              name: "page",
+              in: "query",
+              schema: { type: "integer", default: 1 }
+            },
+            {
+              name: "limit",
+              in: "query",
+              schema: { type: "integer", default: 20 }
+            }
+          ],
+          responses: {
+            200: {
+              description: "Successful response",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    properties: {
+                      success: { type: "boolean" },
+                      data: {
+                        type: "array",
+                        items: { $ref: `#/components/schemas/${resource.name}` }
+                      },
+                      total: { type: "integer" },
+                      page: { type: "integer" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        post: {
+          tags: [resource.name],
+          summary: `Create ${resource.name}`,
+          security: resource.permissions?.create ? [{ bearerAuth: [] }] : [],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${resource.name}` }
+              }
+            }
+          },
+          responses: {
+            201: {
+              description: "Created successfully"
+            }
+          }
+        }
+      };
+      spec.paths[`${basePath}/{id}`] = {
+        get: {
+          tags: [resource.name],
+          summary: `Get ${resource.name} by ID`,
+          security: resource.permissions?.get ? [{ bearerAuth: [] }] : [],
+          parameters: [
+            {
+              name: "id",
+              in: "path",
+              required: true,
+              schema: { type: "string" }
+            }
+          ],
+          responses: {
+            200: {
+              description: "Successful response"
+            }
+          }
+        },
+        patch: {
+          tags: [resource.name],
+          summary: `Update ${resource.name}`,
+          security: resource.permissions?.update ? [{ bearerAuth: [] }] : [],
+          parameters: [
+            {
+              name: "id",
+              in: "path",
+              required: true,
+              schema: { type: "string" }
+            }
+          ],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${resource.name}` }
+              }
+            }
+          },
+          responses: {
+            200: {
+              description: "Updated successfully"
+            }
+          }
+        },
+        delete: {
+          tags: [resource.name],
+          summary: `Delete ${resource.name}`,
+          security: resource.permissions?.delete ? [{ bearerAuth: [] }] : [],
+          parameters: [
+            {
+              name: "id",
+              in: "path",
+              required: true,
+              schema: { type: "string" }
+            }
+          ],
+          responses: {
+            200: {
+              description: "Deleted successfully"
+            }
+          }
+        }
+      };
+      spec.components.schemas[resource.name] = {
+        type: "object",
+        properties: {
+          _id: { type: "string" },
+          createdAt: { type: "string", format: "date-time" },
+          updatedAt: { type: "string", format: "date-time" }
+        }
+      };
+    });
+    const fullPath = join(process.cwd(), outputPath);
+    writeFileSync(fullPath, JSON.stringify(spec, null, 2));
+    console.log(`✅ OpenAPI spec exported to: ${fullPath}`);
+    console.log(`
+Resources included: ${resources.length}`);
+    console.log(`Total endpoints: ${Object.keys(spec.paths).length}`);
+  } catch (error) {
+    console.error("Error:", error.message);
+    process.exit(1);
+  }
+}
+var docs_default = { exportDocs };
+
+export { docs_default as default, exportDocs };

package/dist/cli/commands/introspect.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Arc CLI - Introspect Command
+ *
+ * Shows all registered resources and their configuration
+ */
+declare function introspect(args: string[]): Promise<void>;
+
+export { introspect as default, introspect };