@codexsploitx/schemaapi 1.1.11 → 1.1.13

package/dist/cli/templates/sdk.d.ts

@@ -0,0 +1 @@
+export declare function generateSdkClient(name: string): string;

package/dist/cli/templates/tests.d.ts

@@ -0,0 +1 @@
+export declare function generateTest(name: string): string;

package/dist/cli.js

@@ -6854,6 +6854,208 @@ export const { GET, POST, PUT, DELETE } = handlers;
 `;
 }
 
+function generateSdkClient(name) {
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    return `import { 
+  Create${pascalName}Request, 
+  Create${pascalName}Response,
+  Get${pascalName}Response,
+  Update${pascalName}Request,
+  Update${pascalName}Response,
+  Delete${pascalName}Response,
+  List${pascalName}sResponse
+} from '../../contracts/${name}Contract';
+
+export class ${pascalName}Client {
+  private baseUrl: string;
+  private headers: Record<string, string>;
+
+  constructor(baseUrl: string, token?: string) {
+    this.baseUrl = baseUrl;
+    this.headers = {
+      'Content-Type': 'application/json',
+      ...(token ? { Authorization: \`Bearer \${token}\` } : {}),
+    };
+  }
+
+  /**
+   * Create a new ${camelName}
+   */
+  async create(data: Create${pascalName}Request): Promise<Create${pascalName}Response> {
+    const response = await fetch(\`\${this.baseUrl}/${name}\`, {
+      method: 'POST',
+      headers: this.headers,
+      body: JSON.stringify(data),
+    });
+    
+    if (!response.ok) {
+      throw new Error(\`Failed to create ${camelName}: \${response.statusText}\`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Get a ${camelName} by ID
+   */
+  async get(id: string): Promise<Get${pascalName}Response> {
+    const response = await fetch(\`\${this.baseUrl}/${name}/\${id}\`, {
+      method: 'GET',
+      headers: this.headers,
+    });
+
+    if (!response.ok) {
+      throw new Error(\`Failed to get ${camelName}: \${response.statusText}\`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Update a ${camelName}
+   */
+  async update(id: string, data: Update${pascalName}Request): Promise<Update${pascalName}Response> {
+    const response = await fetch(\`\${this.baseUrl}/${name}/\${id}\`, {
+      method: 'PUT',
+      headers: this.headers,
+      body: JSON.stringify(data),
+    });
+
+    if (!response.ok) {
+      throw new Error(\`Failed to update ${camelName}: \${response.statusText}\`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Delete a ${camelName}
+   */
+  async delete(id: string): Promise<Delete${pascalName}Response> {
+    const response = await fetch(\`\${this.baseUrl}/${name}/\${id}\`, {
+      method: 'DELETE',
+      headers: this.headers,
+    });
+
+    if (!response.ok) {
+      throw new Error(\`Failed to delete ${camelName}: \${response.statusText}\`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * List all ${name}
+   */
+  async list(): Promise<List${pascalName}sResponse> {
+    const response = await fetch(\`\${this.baseUrl}/${name}\`, {
+      method: 'GET',
+      headers: this.headers,
+    });
+
+    if (!response.ok) {
+      throw new Error(\`Failed to list ${name}: \${response.statusText}\`);
+    }
+
+    return response.json();
+  }
+}
+`;
+}
+
+function generateTest(name) {
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    return `import { describe, it, expect, beforeAll } from 'vitest';
+import { ${pascalName}Client } from '../src/sdk/${name}Client';
+
+// CONFIG: Change this to your running API URL
+const BASE_URL = process.env.API_URL || 'http://localhost:3000';
+
+describe('${pascalName} Resource Integration Tests', () => {
+  const client = new ${pascalName}Client(BASE_URL);
+  let createdId: string;
+
+  beforeAll(async () => {
+    // Optional: Check if server is running
+    try {
+      await fetch(BASE_URL);
+    } catch (e) {
+      console.warn('⚠️  Warning: API server might not be running at ' + BASE_URL);
+      console.warn('   Tests might fail if the server is not reachable.');
+    }
+  });
+
+  it('should create a new ${camelName}', async () => {
+    const data = {
+      // TODO: Add required fields based on your contract
+      name: 'Test ${pascalName}',
+      // email: 'test@example.com',
+    };
+
+    try {
+      const response = await client.create(data as any);
+      expect(response).toBeDefined();
+      // Assuming the response has an id
+      if ((response as any).id) {
+        createdId = (response as any).id;
+      }
+    } catch (error) {
+      // Ignore error if server is not implemented yet
+      console.log('Skipping create test (server likely not implemented)');
+    }
+  });
+
+  it('should list all ${name}', async () => {
+    try {
+      const list = await client.list();
+      expect(Array.isArray(list)).toBe(true);
+    } catch (error) {
+      console.log('Skipping list test');
+    }
+  });
+
+  it('should get a ${camelName} by ID', async () => {
+    if (!createdId) return;
+    
+    try {
+      const item = await client.get(createdId);
+      expect(item).toBeDefined();
+    } catch (error) {
+      console.log('Skipping get test');
+    }
+  });
+
+  it('should update a ${camelName}', async () => {
+    if (!createdId) return;
+
+    const updateData = {
+      name: 'Updated ${pascalName}',
+    };
+
+    try {
+      const updated = await client.update(createdId, updateData as any);
+      expect(updated).toBeDefined();
+    } catch (error) {
+      console.log('Skipping update test');
+    }
+  });
+
+  it('should delete a ${camelName}', async () => {
+    if (!createdId) return;
+
+    try {
+      const result = await client.delete(createdId);
+      expect(result).toBeDefined();
+    } catch (error) {
+      console.log('Skipping delete test');
+    }
+  });
+});
+`;
+}
+
 // Helper to load the main library
 function loadSchemaApi() {
     try {
@@ -6865,7 +7067,7 @@ function loadSchemaApi() {
         return {};
     }
 }
-function loadContractsModule$1(contractsDir) {
+function loadContractsModule(contractsDir) {
     const cwd = process.cwd();
     const baseDir = path__namespace.join(cwd, contractsDir || "contracts");
     const candidates = ["index.js", "index.cjs", "index.ts"];
@@ -6925,7 +7127,7 @@ function generateDocs(config) {
     if (adapter || contractsDir) {
         console.log(`Using config: adapter=${adapter || "unknown"}, contractsDir=${contractsDir}`);
     }
-    const contractsModule = loadContractsModule$1(contractsDir);
+    const contractsModule = loadContractsModule(contractsDir);
     if (!contractsModule) {
         console.error(`Could not find contracts entry in ${contractsDir}. Expected index.js or index.cjs`);
         return;
@@ -6979,19 +7181,36 @@ function handleGenerate(args) {
         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"}`);
+        if (!name) {
+            console.error('Usage: schemaapi generate sdk <name>');
+            return;
         }
+        console.log(`Generating SDK Client for "${name}"...`);
+        const cwd = process.cwd();
+        const sdkDir = path__namespace.join(cwd, 'src', 'sdk');
+        ensureDir(sdkDir);
+        const sdkContent = generateSdkClient(name);
+        writeFile(path__namespace.join(sdkDir, `${name}Client.ts`), sdkContent);
+        console.log(`Created SDK Client in src/sdk/${name}Client.ts`);
+        console.log(`\nUsage example:`);
+        console.log(`import { ${name.charAt(0).toUpperCase() + name.slice(1)}Client } from './sdk/${name}Client';`);
+        console.log(`const client = new ${name.charAt(0).toUpperCase() + name.slice(1)}Client('http://localhost:3000');`);
         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"}`);
+        if (!name) {
+            console.error('Usage: schemaapi generate tests <name>');
+            return;
         }
+        console.log(`Generating Integration Tests for "${name}"...`);
+        const cwd = process.cwd();
+        const testsDir = path__namespace.join(cwd, 'tests');
+        ensureDir(testsDir);
+        const testContent = generateTest(name);
+        writeFile(path__namespace.join(testsDir, `${name}.test.ts`), testContent);
+        console.log(`Created Integration Test in tests/${name}.test.ts`);
+        console.log(`\nRequires 'vitest' and the generated SDK.`);
+        console.log(`Run with: npx vitest tests/${name}.test.ts`);
         return;
     }
     if (type !== 'resource') {
@@ -7099,100 +7318,6 @@ function handleGenerate(args) {
     }
 }
 
-function loadContractsModule(contractsDir) {
-    const cwd = process.cwd();
-    const baseDir = path__namespace.join(cwd, contractsDir);
-    const candidates = ["index.js", "index.cjs", "index.ts"];
-    for (const file of candidates) {
-        const fullPath = path__namespace.join(baseDir, file);
-        if (fs__namespace.existsSync(fullPath)) {
-            try {
-                // We use require/import to load the contract objects
-                // In a real TS environment, we might need ts-node/register if loading .ts directly
-                // But assuming the user has compiled code or we are running in a compatible env:
-                if (file.endsWith('.ts')) {
-                    try {
-                        // Register ts-node with specific options to handle imports correctly
-                        require('ts-node').register({
-                            transpileOnly: true,
-                            compilerOptions: {
-                                module: 'commonjs',
-                                esModuleInterop: true
-                            }
-                        });
-                    }
-                    catch (e) {
-                        // Ignore if ts-node is not available
-                    }
-                }
-                return require(fullPath);
-            }
-            catch (error) {
-                console.error(`Failed to load contracts module at ${fullPath}:`, (error && error.message) || error);
-                return null;
-            }
-        }
-    }
-    return null;
-}
-function handleAudit(args) {
-    const config = loadConfig();
-    const contractsDir = config?.contractsDir || "contracts";
-    console.log(`🔍 Starting SchemaApi Audit in directory: ${contractsDir}`);
-    const contractsModule = loadContractsModule(contractsDir);
-    if (!contractsModule) {
-        console.error(`❌ Could not find contracts entry in ${contractsDir}. Make sure index.ts/js exists and exports your contracts.`);
-        return;
-    }
-    let totalIssues = 0;
-    const candidates = Object.values(contractsModule).filter((value) => value &&
-        typeof value === "object" &&
-        typeof value.docs === "function" // Duck typing for Contract
-    );
-    if (candidates.length === 0) {
-        console.warn("⚠️  No contracts found exported in the entry file.");
-        return;
-    }
-    candidates.forEach((contract, index) => {
-        const docs = contract.docs(); // This returns the contract structure
-        const routes = docs.routes || [];
-        console.log(`\n📄 Contract #${index + 1}: Found ${routes.length} routes`);
-        routes.forEach((route) => {
-            const issues = [];
-            const method = route.method;
-            const pathStr = route.path;
-            const fullRoute = `${method} ${pathStr}`;
-            // 1. Security Check: Roles
-            if (!route.roles || route.roles.length === 0) {
-                issues.push(`⚠️  [Security] No roles defined. Endpoint is public? Consider adding explicit roles or 'public'.`);
-            }
-            // 2. Validation Check: Params
-            // Basic check: if path has :param, schema should have it
-            const pathParams = (pathStr.match(/:[a-zA-Z0-9_]+/g) || []).map((p) => p.substring(1));
-            if (pathParams.length > 0) ;
-            // 3. Completeness: Errors
-            if (!route.errors || Object.keys(route.errors).length === 0) {
-                issues.push(`ℹ️  [Best Practice] No error status codes defined. Clients won't know what errors to expect.`);
-            }
-            if (issues.length > 0) {
-                console.log(`  🔸 ${fullRoute}`);
-                issues.forEach(issue => console.log(`     ${issue}`));
-                totalIssues += issues.length;
-            }
-            else {
-                console.log(`  ✅ ${fullRoute}`);
-            }
-        });
-    });
-    console.log(`\n🏁 Audit complete.`);
-    if (totalIssues > 0) {
-        console.log(`Found ${totalIssues} potential issues.`);
-    }
-    else {
-        console.log(`No obvious issues found. Great job! 🎉`);
-    }
-}
-
 async function cli(args) {
     const command = args[0];
     switch (command) {
@@ -7202,8 +7327,21 @@ async function cli(args) {
         case 'generate':
             handleGenerate(args.slice(1));
             break;
-        case 'audit':
-            handleAudit(args.slice(1));
+        case 'help':
+        case '--help':
+        case '-h':
+            console.log(`
+@codexsploitx/schemaapi CLI
+
+Usage:
+  npx @codexsploitx/schemaapi init <framework>          Initialize configuration
+  npx @codexsploitx/schemaapi generate resource <name>  Generate Backend Resource (API Routes)
+  npx @codexsploitx/schemaapi generate docs             Generate documentation
+  npx @codexsploitx/schemaapi generate sdk <name>       Generate Frontend Client (SDK)
+  npx @codexsploitx/schemaapi generate tests <name>     Generate Integration Tests
+  npx @codexsploitx/schemaapi adapters                  List available adapters
+  npx @codexsploitx/schemaapi help                      Show this help message
+`);
             break;
         case 'adapters':
             console.log(`
@@ -7221,16 +7359,9 @@ Available Adapters:
             break;
         default:
             console.log(`
-SchemaApi CLI
+Unknown command: ${command}
 
-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
-  npx schemaapi adapters               List available adapters
+Run 'npx @codexsploitx/schemaapi help' to see available commands.
 `);
     }
 }