@codexsploitx/schemaapi 1.0.5 → 1.1.7

package/dist/cli.js

@@ -0,0 +1,819 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+function loadConfig() {
+    const cwd = process.cwd();
+    const configPath = path__namespace.join(cwd, "schemaapi.config.json");
+    if (!fs__namespace.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const raw = fs__namespace.readFileSync(configPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function ensureDir(dir) {
+    if (!fs__namespace.existsSync(dir)) {
+        fs__namespace.mkdirSync(dir, { recursive: true });
+    }
+}
+function writeFile(filePath, content) {
+    ensureDir(path__namespace.dirname(filePath));
+    fs__namespace.writeFileSync(filePath, content, 'utf8');
+}
+function toPascalCase(str) {
+    return str.replace(/(^\w|-\w)/g, (clear) => clear.replace(/-/, "").toUpperCase());
+}
+function toCamelCase(str) {
+    return str.replace(/-\w/g, (clear) => clear[1].toUpperCase());
+}
+
+function normalizeAdapter(value) {
+    if (!value)
+        return "generic";
+    const v = String(value).toLowerCase();
+    if (v === "next" || v === "nextjs")
+        return "next";
+    if (v === "remix")
+        return "remix";
+    if (v === "express")
+        return "express";
+    if (v === "fastify")
+        return "fastify";
+    if (v === "nest" || v === "nestjs")
+        return "nest";
+    if (v === "koa")
+        return "koa";
+    if (v === "hapi")
+        return "hapi";
+    if (v === "deno")
+        return "deno";
+    return v;
+}
+function handleInit(adapterArg) {
+    const adapter = normalizeAdapter(adapterArg);
+    const cwd = process.cwd();
+    const contractsDir = path__namespace.join(cwd, "contracts");
+    ensureDir(contractsDir);
+    const usersContractPath = path__namespace.join(contractsDir, "usersContract.ts");
+    if (!fs__namespace.existsSync(usersContractPath)) {
+        const usersContractContent = [
+            'import { createContract } from "@codexsploitx/schemaapi";',
+            'import { z } from "zod";',
+            "",
+            "export const usersContract = createContract({",
+            '  "/users/:id": {',
+            "    GET: {",
+            "      params: z.object({ id: z.string() }),",
+            "      response: z.object({ id: z.string(), name: z.string() }),",
+            "    },",
+            "  },",
+            "});",
+            "",
+        ].join("\n");
+        writeFile(usersContractPath, usersContractContent);
+    }
+    const indexPath = path__namespace.join(contractsDir, "index.ts");
+    if (!fs__namespace.existsSync(indexPath)) {
+        writeFile(indexPath, 'export * from "./usersContract";\n');
+    }
+    if (adapter === "next") {
+        const appApiUsersDir = path__namespace.join(cwd, "app", "api", "users");
+        ensureDir(appApiUsersDir);
+        const routePath = path__namespace.join(appApiUsersDir, "route.ts");
+        if (!fs__namespace.existsSync(routePath)) {
+            const nextRouteContent = [
+                'import { adapters } from "@codexsploitx/schemaapi";',
+                'import { usersContract } from "../../../contracts";',
+                "",
+                "const handlers = adapters.next.handleContract(usersContract, {",
+                '  "GET /users/:id": async ({ params }) => {',
+                "    return {",
+                "      id: String(params && params.id),",
+                '      name: "John Doe",',
+                "    };",
+                "  },",
+                "});",
+                "",
+                "export const GET = handlers.GET;",
+                "",
+            ].join("\n");
+            writeFile(routePath, nextRouteContent);
+        }
+    }
+    const configPath = path__namespace.join(cwd, "schemaapi.config.json");
+    let existingConfig = null;
+    if (fs__namespace.existsSync(configPath)) {
+        try {
+            const raw = fs__namespace.readFileSync(configPath, "utf8");
+            existingConfig = JSON.parse(raw);
+        }
+        catch {
+            existingConfig = null;
+        }
+    }
+    const config = {
+        ...(existingConfig || {}),
+        adapter,
+        contractsDir: existingConfig?.contractsDir || "contracts",
+    };
+    writeFile(configPath, JSON.stringify(config, null, 2));
+    console.log(`Initialized SchemaApi with adapter "${adapter}"`);
+}
+
+function generateContract(name) {
+    const camelName = name.replace(/^[A-Z]/, c => c.toLowerCase());
+    return `import { createContract } from "@codexsploitx/schemaapi";
+import { z } from "zod";
+
+const ${camelName}Schema = z.object({
+  id: z.string(),
+  name: z.string(),
+  createdAt: z.string().datetime(),
+});
+
+export const ${camelName}Contract = createContract({
+  "/${name}": {
+    GET: {
+      query: z.object({
+        limit: z.string().optional().transform(Number),
+        offset: z.string().optional().transform(Number),
+      }),
+      response: z.array(${camelName}Schema),
+    },
+    POST: {
+      body: ${camelName}Schema.omit({ id: true, createdAt: true }),
+      response: ${camelName}Schema,
+    },
+  },
+  "/${name}/:id": {
+    GET: {
+      params: z.object({ id: z.string() }),
+      response: ${camelName}Schema,
+    },
+    PUT: {
+      params: z.object({ id: z.string() }),
+      body: ${camelName}Schema.partial(),
+      response: ${camelName}Schema,
+    },
+    DELETE: {
+      params: z.object({ id: z.string() }),
+      response: z.object({ success: z.boolean() }),
+    },
+  },
+});
+`;
+}
+
+function generateNestModule(name) {
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    return `import { Module, OnModuleInit, INestApplication } from '@nestjs/common';
+import { ${camelName}Service } from './${name}.service';
+import { adapters } from '@codexsploitx/schemaapi';
+import { ${camelName}Contract } from '../../contracts/${name}.contract';
+
+@Module({
+  providers: [${pascalName}Service],
+  exports: [${pascalName}Service],
+})
+export class ${pascalName}Module implements OnModuleInit {
+  constructor(private readonly service: ${pascalName}Service) {}
+
+  onModuleInit() {
+    // Note: SchemaApi registration requires the app instance.
+    // Usually done in main.ts or via a global module.
+    // This is a placeholder for the implementation logic.
+  }
+
+  static register(app: INestApplication) {
+    const service = app.get(${pascalName}Service);
+    
+    adapters.nest.SchemaApiModule.register(app, ${camelName}Contract, {
+      "GET /${name}": async (ctx) => service.findAll(ctx.query),
+      "POST /${name}": async (ctx) => service.create(ctx.body),
+      "GET /${name}/:id": async (ctx) => service.findOne(ctx.params.id),
+      "PUT /${name}/:id": async (ctx) => service.update(ctx.params.id, ctx.body),
+      "DELETE /${name}/:id": async (ctx) => service.remove(ctx.params.id),
+    });
+  }
+}
+`;
+}
+function generateNestService(name) {
+    const pascalName = toPascalCase(name);
+    toCamelCase(name);
+    return `import { Injectable, NotFoundException } from '@nestjs/common';
+
+@Injectable()
+export class ${pascalName}Service {
+  private items = [];
+
+  async findAll(query: any) {
+    return this.items;
+  }
+
+  async create(data: any) {
+    const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...data };
+    this.items.push(newItem);
+    return newItem;
+  }
+
+  async findOne(id: string) {
+    const item = this.items.find(i => i.id === id);
+    if (!item) throw new NotFoundException();
+    return item;
+  }
+
+  async update(id: string, data: any) {
+    const index = this.items.findIndex(i => i.id === id);
+    if (index === -1) throw new NotFoundException();
+    this.items[index] = { ...this.items[index], ...data };
+    return this.items[index];
+  }
+
+  async remove(id: string) {
+    const index = this.items.findIndex(i => i.id === id);
+    if (index === -1) throw new NotFoundException();
+    this.items.splice(index, 1);
+    return { success: true };
+  }
+}
+`;
+}
+
+function generateExpressRoute(name) {
+    const camelName = toCamelCase(name);
+    return `import { Router } from "express";
+import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../contracts/${name}Contract";
+
+export const ${camelName}Router = Router();
+
+// Mock database
+const items: any[] = [];
+
+adapters.express.handleContract(${camelName}Router, ${camelName}Contract, {
+  "GET /${name}": async ({ query }) => {
+    return items;
+  },
+  "POST /${name}": async ({ body }) => {
+    const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...body };
+    items.push(newItem);
+    return newItem;
+  },
+  "GET /${name}/:id": async ({ params }) => {
+    const item = items.find((i) => i.id === params.id);
+    if (!item) throw { status: 404, message: "Not Found" };
+    return item;
+  },
+  "PUT /${name}/:id": async ({ params, body }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) throw { status: 404, message: "Not Found" };
+    items[index] = { ...items[index], ...body };
+    return items[index];
+  },
+  "DELETE /${name}/:id": async ({ params }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) throw { status: 404, message: "Not Found" };
+    items.splice(index, 1);
+    return { success: true };
+  },
+});
+`;
+}
+
+function generateFastifyRoute(name) {
+    const camelName = toCamelCase(name);
+    return `import { FastifyInstance } from "fastify";
+import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../contracts/${name}Contract";
+
+// Mock database
+const items: any[] = [];
+
+export async function ${camelName}Routes(fastify: FastifyInstance) {
+  adapters.fastify.handleContract(fastify, ${camelName}Contract, {
+    "GET /${name}": async ({ query }) => {
+      return items;
+    },
+    "POST /${name}": async ({ body }) => {
+      const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...body };
+      items.push(newItem);
+      return newItem;
+    },
+    "GET /${name}/:id": async ({ params }) => {
+      const item = items.find((i) => i.id === params.id);
+      if (!item) throw { status: 404, message: "Not Found" };
+      return item;
+    },
+    "PUT /${name}/:id": async ({ params, body }) => {
+      const index = items.findIndex((i) => i.id === params.id);
+      if (index === -1) throw { status: 404, message: "Not Found" };
+      items[index] = { ...items[index], ...body };
+      return items[index];
+    },
+    "DELETE /${name}/:id": async ({ params }) => {
+      const index = items.findIndex((i) => i.id === params.id);
+      if (index === -1) throw { status: 404, message: "Not Found" };
+      items.splice(index, 1);
+      return { success: true };
+    },
+  });
+}
+`;
+}
+
+function generateKoaRoute(name) {
+    const camelName = toCamelCase(name);
+    return `import Router from "@koa/router";
+import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../contracts/${name}Contract";
+
+export const ${camelName}Router = new Router();
+
+// Mock database
+const items: any[] = [];
+
+adapters.koa.handleContract(${camelName}Router, ${camelName}Contract, {
+  "GET /${name}": async ({ query }) => {
+    return items;
+  },
+  "POST /${name}": async ({ body }) => {
+    const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...body };
+    items.push(newItem);
+    return newItem;
+  },
+  "GET /${name}/:id": async ({ params }) => {
+    const item = items.find((i) => i.id === params.id);
+    if (!item) throw { status: 404, message: "Not Found" };
+    return item;
+  },
+  "PUT /${name}/:id": async ({ params, body }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) throw { status: 404, message: "Not Found" };
+    items[index] = { ...items[index], ...body };
+    return items[index];
+  },
+  "DELETE /${name}/:id": async ({ params }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) throw { status: 404, message: "Not Found" };
+    items.splice(index, 1);
+    return { success: true };
+  },
+});
+`;
+}
+
+function generateHapiRoute(name) {
+    const camelName = toCamelCase(name);
+    const pascalName = toPascalCase(name);
+    return `import Hapi from "@hapi/hapi";
+import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../contracts/${name}Contract";
+
+// Mock database
+const items: any[] = [];
+
+export async function register${pascalName}Routes(server: Hapi.Server) {
+  adapters.hapi.handleContract(server, ${camelName}Contract, {
+    "GET /${name}": async ({ query }) => {
+      return items;
+    },
+    "POST /${name}": async ({ body }) => {
+      const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...body };
+      items.push(newItem);
+      return newItem;
+    },
+    "GET /${name}/:id": async ({ params }) => {
+      const item = items.find((i) => i.id === params.id);
+      if (!item) throw { status: 404, message: "Not Found" };
+      return item;
+    },
+    "PUT /${name}/:id": async ({ params, body }) => {
+      const index = items.findIndex((i) => i.id === params.id);
+      if (index === -1) throw { status: 404, message: "Not Found" };
+      items[index] = { ...items[index], ...body };
+      return items[index];
+    },
+    "DELETE /${name}/:id": async ({ params }) => {
+      const index = items.findIndex((i) => i.id === params.id);
+      if (index === -1) throw { status: 404, message: "Not Found" };
+      items.splice(index, 1);
+      return { success: true };
+    },
+  });
+}
+`;
+}
+
+function generateDenoRoute(name) {
+    const camelName = toCamelCase(name);
+    return `import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../contracts/${name}Contract.ts";
+
+// Mock database
+const items: any[] = [];
+
+export const handler = adapters.deno.handleContract(${camelName}Contract, {
+  "GET /${name}": async ({ query }) => {
+    return items;
+  },
+  "POST /${name}": async ({ body }) => {
+    const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...body };
+    items.push(newItem);
+    return newItem;
+  },
+  "GET /${name}/:id": async ({ params }) => {
+    const item = items.find((i) => i.id === params.id);
+    if (!item) return new Response("Not Found", { status: 404 });
+    return item;
+  },
+  "PUT /${name}/:id": async ({ params, body }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) return new Response("Not Found", { status: 404 });
+    items[index] = { ...items[index], ...body };
+    return items[index];
+  },
+  "DELETE /${name}/:id": async ({ params }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) return new Response("Not Found", { status: 404 });
+    items.splice(index, 1);
+    return { success: true };
+  },
+});
+`;
+}
+
+function generateRemixRoute(name) {
+    const camelName = toCamelCase(name);
+    return `import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../contracts/${name}Contract";
+import type { ActionFunctionArgs, LoaderFunctionArgs } from "@remix-run/node";
+
+// Mock database
+const items: any[] = [];
+
+const handlers = {
+  "GET /${name}": async ({ query }) => {
+    return items;
+  },
+  "POST /${name}": async ({ body }) => {
+    const newItem = { id: Date.now().toString(), createdAt: new Date().toISOString(), ...body };
+    items.push(newItem);
+    return newItem;
+  },
+  "GET /${name}/:id": async ({ params }) => {
+    const item = items.find((i) => i.id === params.id);
+    if (!item) throw new Response("Not Found", { status: 404 });
+    return item;
+  },
+  "PUT /${name}/:id": async ({ params, body }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) throw new Response("Not Found", { status: 404 });
+    items[index] = { ...items[index], ...body };
+    return items[index];
+  },
+  "DELETE /${name}/:id": async ({ params }) => {
+    const index = items.findIndex((i) => i.id === params.id);
+    if (index === -1) throw new Response("Not Found", { status: 404 });
+    items.splice(index, 1);
+    return { success: true };
+  },
+};
+
+const { loader, action } = adapters.remix.createRouteHandlers(
+  ${camelName}Contract,
+  handlers,
+  "/${name}" // Adjust route pattern if needed
+);
+
+export { loader, action };
+`;
+}
+
+function generateNextRoute(name) {
+    const camelName = toCamelCase(name);
+    return `import { adapters } from "@codexsploitx/schemaapi";
+import { ${camelName}Contract } from "../../../contracts/${name}Contract";
+
+const handlers = adapters.next.handleContract(${camelName}Contract, {
+  "GET /${name}": async ({ query }) => {
+    return [];
+  },
+  "POST /${name}": async ({ body }) => {
+    return { id: "1", ...body, createdAt: new Date().toISOString() };
+  },
+  "GET /${name}/:id": async ({ params }) => {
+    return { id: params.id, name: "Item " + params.id };
+  },
+  "PUT /${name}/:id": async ({ params, body }) => {
+    return { id: params.id, ...body };
+  },
+  "DELETE /${name}/:id": async ({ params }) => {
+    return { success: true };
+  },
+});
+
+export const { GET, POST, PUT, DELETE } = handlers;
+`;
+}
+
+// Helper to load the main library
+function loadSchemaApi() {
+    try {
+        // When running from dist/cli.js, .. resolves to project root
+        // which should load the main entry point defined in package.json
+        return require(path__namespace.resolve(__dirname, '../../..'));
+    }
+    catch {
+        return {};
+    }
+}
+function loadContractsModule(contractsDir) {
+    const cwd = process.cwd();
+    const baseDir = path__namespace.join(cwd, contractsDir || "contracts");
+    const candidates = ["index.js", "index.cjs", "index.ts"];
+    // In a CLI context, we might be running against TS source (via ts-node) or compiled JS.
+    // The original CLI looked for compiled files. Let's try to support TS if registered, 
+    // but primarily look for what the user has.
+    // Note: requiring .ts files natively without ts-node registration won't work in standard node.
+    // The original CLI used require() so it likely expected the user to have compiled contracts 
+    // OR was running in a dev environment that supported it.
+    // For safety, we'll try standard require.
+    for (const file of candidates) {
+        const fullPath = path__namespace.join(baseDir, file);
+        if (fs__namespace.existsSync(fullPath)) {
+            try {
+                return require(fullPath);
+            }
+            catch (error) {
+                // If it's a syntax error due to TS, we might want to warn
+                console.error(`Failed to load contracts module at ${fullPath}:`, (error && error.message) || error);
+                // Continue to next candidate? No, if found but failed, it's an error.
+                return null;
+            }
+        }
+    }
+    // If we didn't find index.js/cjs, maybe the user is in a TS project and hasn't compiled contracts yet?
+    // The original CLI errored here.
+    return null;
+}
+function renderDocsHtmlFallback(docs) {
+    const items = Array.isArray(docs.routes)
+        ? docs.routes
+            .map((route) => {
+            const method = route && route.method ? String(route.method) : "";
+            const pathValue = route && route.path ? String(route.path) : "";
+            return `<li><code>${method} ${pathValue}</code></li>`;
+        })
+            .join("\n")
+        : "";
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>SchemaApi Docs</title>
+</head>
+<body>
+  <h1>SchemaApi Docs</h1>
+  <ul>
+${items}
+  </ul>
+</body>
+</html>`;
+}
+function generateDocs(config) {
+    const adapter = config && config.adapter ? String(config.adapter) : null;
+    const contractsDir = config && config.contractsDir ? String(config.contractsDir) : "contracts";
+    console.log("Generating docs from contract");
+    if (adapter || contractsDir) {
+        console.log(`Using config: adapter=${adapter || "unknown"}, contractsDir=${contractsDir}`);
+    }
+    const contractsModule = loadContractsModule(contractsDir);
+    if (!contractsModule) {
+        console.error(`Could not find contracts entry in ${contractsDir}. Expected index.js or index.cjs`);
+        return;
+    }
+    const candidates = Object.values(contractsModule).filter((value) => value &&
+        typeof value === "object" &&
+        typeof value.docs === "function");
+    if (candidates.length === 0) {
+        console.error("No contracts with a docs() method were found in the contracts entry file.");
+        return;
+    }
+    const combinedDocs = {
+        routes: candidates.flatMap((contract) => {
+            try {
+                const docs = contract.docs();
+                return Array.isArray(docs.routes) ? docs.routes : [];
+            }
+            catch {
+                return [];
+            }
+        }),
+    };
+    if (!combinedDocs.routes.length) {
+        console.error("Contracts loaded, but no routes were found when calling docs().");
+        return;
+    }
+    const outDir = path__namespace.join(process.cwd(), "schemaapi-docs");
+    if (!fs__namespace.existsSync(outDir)) {
+        fs__namespace.mkdirSync(outDir, { recursive: true });
+    }
+    const outPath = path__namespace.join(outDir, "index.html");
+    const schemaapi = loadSchemaApi();
+    const hasRenderDocs = schemaapi && typeof schemaapi.renderDocs === "function";
+    const html = hasRenderDocs
+        ? schemaapi.renderDocs(combinedDocs, {
+            format: "html",
+            title: "SchemaApi Docs",
+            theme: "dark",
+        })
+        : renderDocsHtmlFallback(combinedDocs);
+    fs__namespace.writeFileSync(outPath, html, "utf8");
+    console.log(`Docs generated at: ${path__namespace.relative(process.cwd(), outPath)}`);
+}
+
+function handleGenerate(args) {
+    const [type, name] = args;
+    const config = loadConfig();
+    let adapter = config?.adapter;
+    if (type === 'docs') {
+        generateDocs(config || {});
+        return;
+    }
+    if (type === 'sdk') {
+        console.log("Generating SDK from contract");
+        // Placeholder restoration
+        if (adapter || config?.contractsDir) {
+            console.log(`Using config: adapter=${adapter || "unknown"}, contractsDir=${config?.contractsDir || "contracts"}`);
+        }
+        return;
+    }
+    if (type === 'tests') {
+        console.log("Generating tests from contract");
+        // Placeholder restoration
+        if (adapter || config?.contractsDir) {
+            console.log(`Using config: adapter=${adapter || "unknown"}, contractsDir=${config?.contractsDir || "contracts"}`);
+        }
+        return;
+    }
+    if (type !== 'resource') {
+        console.error(`Unknown generate type: ${type}. Supported: resource, docs, sdk, tests`);
+        return;
+    }
+    if (!name) {
+        console.error('Usage: schemaapi generate resource <name>');
+        return;
+    }
+    if (!adapter) {
+        console.warn("⚠️  No schemaapi.config.json found. Defaulting to 'express'.");
+        console.warn("   Run 'npx schemaapi init <framework>' to set your preference permanently.");
+        adapter = 'express';
+    }
+    const cwd = process.cwd();
+    console.log(`Generating resource "${name}" for adapter "${adapter}"...`);
+    // 1. Generate Contract
+    const contractsDir = path__namespace.join(cwd, config?.contractsDir || 'contracts');
+    const contractContent = generateContract(name);
+    const contractPath = path__namespace.join(contractsDir, `${name}Contract.ts`);
+    if (fs__namespace.existsSync(contractPath)) {
+        console.warn(`Contract ${contractPath} already exists. Skipping.`);
+    }
+    else {
+        writeFile(contractPath, contractContent);
+        console.log(`Created contract: ${contractPath}`);
+        // Update index.ts in contracts if exists
+        const indexContractPath = path__namespace.join(contractsDir, 'index.ts');
+        if (fs__namespace.existsSync(indexContractPath)) {
+            const indexContent = fs__namespace.readFileSync(indexContractPath, 'utf8');
+            if (!indexContent.includes(`./${name}Contract`)) {
+                fs__namespace.appendFileSync(indexContractPath, `export * from "./${name}Contract";\n`);
+                console.log(`Updated contracts/index.ts`);
+            }
+        }
+    }
+    // 2. Generate Implementation based on adapter
+    switch (adapter) {
+        case 'nest': {
+            const srcDir = path__namespace.join(cwd, 'src', name);
+            const serviceContent = generateNestService(name);
+            const moduleContent = generateNestModule(name);
+            writeFile(path__namespace.join(srcDir, `${name}.service.ts`), serviceContent);
+            writeFile(path__namespace.join(srcDir, `${name}.module.ts`), moduleContent);
+            console.log(`Created NestJS resources in src/${name}`);
+            console.log(`\nIMPORTANT: Register ${name}Module.register(app) in your main.ts or AppModule!`);
+            break;
+        }
+        case 'express': {
+            const routesDir = path__namespace.join(cwd, 'src', 'routes');
+            const routeContent = generateExpressRoute(name);
+            writeFile(path__namespace.join(routesDir, `${name}.ts`), routeContent);
+            console.log(`Created Express router in src/routes/${name}.ts`);
+            console.log(`\nIMPORTANT: Mount the router in your app: app.use(routes.${name}Router)`);
+            break;
+        }
+        case 'fastify': {
+            const routesDir = path__namespace.join(cwd, 'src', 'routes');
+            const routeContent = generateFastifyRoute(name);
+            writeFile(path__namespace.join(routesDir, `${name}.ts`), routeContent);
+            console.log(`Created Fastify routes in src/routes/${name}.ts`);
+            console.log(`\nIMPORTANT: Register the routes in your app: fastify.register(${name}Routes)`);
+            break;
+        }
+        case 'koa': {
+            const routesDir = path__namespace.join(cwd, 'src', 'routes');
+            const routeContent = generateKoaRoute(name);
+            writeFile(path__namespace.join(routesDir, `${name}.ts`), routeContent);
+            console.log(`Created Koa router in src/routes/${name}.ts`);
+            console.log(`\nIMPORTANT: Use the router in your app: app.use(${name}Router.routes())`);
+            break;
+        }
+        case 'hapi': {
+            const routesDir = path__namespace.join(cwd, 'src', 'routes');
+            const routeContent = generateHapiRoute(name);
+            writeFile(path__namespace.join(routesDir, `${name}.ts`), routeContent);
+            console.log(`Created Hapi routes in src/routes/${name}.ts`);
+            console.log(`\nIMPORTANT: Register routes: await register${name.charAt(0).toUpperCase() + name.slice(1)}Routes(server)`);
+            break;
+        }
+        case 'deno': {
+            const routesDir = path__namespace.join(cwd, 'src', 'handlers');
+            const routeContent = generateDenoRoute(name);
+            writeFile(path__namespace.join(routesDir, `${name}.ts`), routeContent);
+            console.log(`Created Deno handler in src/handlers/${name}.ts`);
+            break;
+        }
+        case 'remix': {
+            const routesDir = path__namespace.join(cwd, 'app', 'routes');
+            const routeContent = generateRemixRoute(name);
+            writeFile(path__namespace.join(routesDir, `${name}.tsx`), routeContent);
+            console.log(`Created Remix route in app/routes/${name}.tsx`);
+            break;
+        }
+        case 'next': {
+            const routeDir = path__namespace.join(cwd, 'app', 'api', name);
+            const routeContent = generateNextRoute(name);
+            writeFile(path__namespace.join(routeDir, 'route.ts'), routeContent);
+            console.log(`Created Next.js route in app/api/${name}/route.ts`);
+            break;
+        }
+        default:
+            console.warn(`Adapter "${adapter}" scaffolding is not yet fully supported.`);
+    }
+}
+
+const args = process.argv.slice(2);
+const command = args[0];
+switch (command) {
+    case 'init':
+        handleInit(args[1]);
+        break;
+    case 'generate':
+        handleGenerate(args.slice(1));
+        break;
+    case 'audit':
+        console.log('Running SchemaApi audit');
+        // Minimal implementation for now, as it was in the original
+        break;
+    default:
+        console.log(`
+SchemaApi CLI
+
+Usage:
+  npx schemaapi init <framework>       Initialize configuration
+  npx schemaapi generate resource <name>  Generate a new resource
+  npx schemaapi generate docs          Generate documentation
+  npx schemaapi generate sdk           Generate SDK (coming soon)
+  npx schemaapi generate tests         Generate tests (coming soon)
+  npx schemaapi audit                  Audit contracts
+`);
+}
+//# sourceMappingURL=cli.js.map