@contractspec/lib.source-extractors 0.10.1 → 0.12.0

package/dist/browser/codegen/index.js

@@ -0,0 +1,225 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/codegen/index.ts
+var exports_codegen = {};
+__export(exports_codegen, {
+  generateSchemas: () => generateSchemas,
+  generateSchema: () => generateSchema,
+  generateRegistry: () => generateRegistry,
+  generateOperations: () => generateOperations,
+  generateOperation: () => generateOperation
+});
+
+// src/codegen/operation-gen.ts
+function generateOperation(endpoint, options) {
+  const specName = toSpecName(endpoint);
+  const fileName = `${toFileName(endpoint)}.ts`;
+  const code = generateOperationCode(endpoint, specName, options);
+  return {
+    path: fileName,
+    content: code,
+    type: "operation"
+  };
+}
+function generateOperations(ir, options) {
+  return ir.endpoints.map((endpoint) => generateOperation(endpoint, options));
+}
+function toSpecName(endpoint) {
+  const parts = endpoint.path.replace(/^\//, "").split("/").filter((p) => p && !p.startsWith(":") && !p.startsWith("{"));
+  const methodPart = endpoint.method.toLowerCase();
+  const pathPart = parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  return `${methodPart}${pathPart}Spec`;
+}
+function toFileName(endpoint) {
+  const parts = endpoint.path.replace(/^\//, "").split("/").filter((p) => p && !p.startsWith(":") && !p.startsWith("{"));
+  const methodPart = endpoint.method.toLowerCase();
+  const pathPart = parts.join("-");
+  return `${methodPart}-${pathPart}`.replace(/--+/g, "-");
+}
+function generateOperationCode(endpoint, specName, options) {
+  const isCommand = endpoint.kind === "command";
+  const defineFunc = isCommand ? "defineCommand" : "defineQuery";
+  const auth = options.defaultAuth ?? "user";
+  const owners = options.defaultOwners ?? ["team"];
+  const lines = [
+    `/**`,
+    ` * ${endpoint.method} ${endpoint.path}`,
+    ` *`,
+    ` * Generated from: ${endpoint.source.file}:${endpoint.source.startLine}`,
+    ` * Confidence: ${endpoint.confidence.level}`,
+    ` */`,
+    ``,
+    `import { ${defineFunc} } from '@contractspec/lib.contracts';`,
+    `import { fromZod } from '@contractspec/lib.schema';`,
+    `import { z } from 'zod';`,
+    ``,
+    `// TODO: Define input schema based on extracted information`,
+    `const inputSchema = fromZod(z.object({`,
+    `  // Add fields here`,
+    `}));`,
+    ``,
+    `// TODO: Define output schema`,
+    `const outputSchema = fromZod(z.object({`,
+    `  // Add fields here`,
+    `}));`,
+    ``,
+    `export const ${specName} = ${defineFunc}({`,
+    `  meta: {`,
+    `    name: '${endpoint.handlerName ?? endpoint.id}',`,
+    `    version: 1,`,
+    `    stability: 'experimental',`,
+    `    owners: ${JSON.stringify(owners)},`,
+    `    goal: 'TODO: Describe the business goal',`,
+    `    context: 'Generated from ${endpoint.source.file}',`,
+    `  },`,
+    `  io: {`,
+    `    input: inputSchema,`,
+    `    output: outputSchema,`,
+    `  },`,
+    `  policy: {`,
+    `    auth: '${auth}',`,
+    `  },`,
+    `  transport: {`,
+    `    rest: {`,
+    `      method: '${endpoint.method}',`,
+    `      path: '${endpoint.path}',`,
+    `    },`,
+    `  },`,
+    `});`,
+    ``
+  ];
+  return lines.join(`
+`);
+}
+// src/codegen/schema-gen.ts
+function generateSchema(schema, _options) {
+  const fileName = `${toFileName2(schema.name)}.ts`;
+  const code = generateSchemaCode(schema);
+  return {
+    path: `schemas/${fileName}`,
+    content: code,
+    type: "schema"
+  };
+}
+function generateSchemas(ir, options) {
+  return ir.schemas.map((schema) => generateSchema(schema, options));
+}
+function toFileName2(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function generateSchemaCode(schema) {
+  const lines = [
+    `/**`,
+    ` * ${schema.name}`,
+    ` *`,
+    ` * Generated from: ${schema.source.file}:${schema.source.startLine}`,
+    ` * Schema type: ${schema.schemaType}`,
+    ` * Confidence: ${schema.confidence.level}`,
+    ` */`,
+    ``,
+    `import { fromZod } from '@contractspec/lib.schema';`,
+    `import { z } from 'zod';`,
+    ``
+  ];
+  if (schema.rawDefinition && schema.schemaType === "zod") {
+    lines.push(`// Original definition from source:`);
+    lines.push(`// ${schema.rawDefinition.split(`
+`)[0]}`);
+    lines.push(``);
+  }
+  lines.push(`export const ${schema.name}Schema = fromZod(z.object({`);
+  if (schema.fields && schema.fields.length > 0) {
+    for (const field of schema.fields) {
+      const zodType = mapToZodType(field.type, field.optional);
+      lines.push(`  ${field.name}: ${zodType},`);
+    }
+  } else {
+    lines.push(`  // TODO: Define schema fields`);
+  }
+  lines.push(`}));`);
+  lines.push(``);
+  lines.push(`export type ${schema.name} = z.infer<typeof ${schema.name}Schema.zodSchema>;`);
+  lines.push(``);
+  return lines.join(`
+`);
+}
+function mapToZodType(tsType, optional) {
+  let zodType;
+  switch (tsType.toLowerCase()) {
+    case "string":
+      zodType = "z.string()";
+      break;
+    case "number":
+      zodType = "z.number()";
+      break;
+    case "boolean":
+      zodType = "z.boolean()";
+      break;
+    case "date":
+      zodType = "z.date()";
+      break;
+    case "string[]":
+    case "array<string>":
+      zodType = "z.array(z.string())";
+      break;
+    case "number[]":
+    case "array<number>":
+      zodType = "z.array(z.number())";
+      break;
+    default:
+      zodType = "z.unknown()";
+  }
+  return optional ? `${zodType}.optional()` : zodType;
+}
+// src/codegen/registry-gen.ts
+function generateRegistry(operationFiles) {
+  const operationImports = operationFiles.filter((f) => f.type === "operation").map((f) => {
+    const name = f.path.replace(".ts", "").replace(/-/g, "_");
+    const specName = toPascalCase(name) + "Spec";
+    return { path: f.path, name, specName };
+  });
+  const lines = [
+    `/**`,
+    ` * Generated operation registry.`,
+    ` */`,
+    ``,
+    `import { OperationSpecRegistry } from '@contractspec/lib.contracts';`,
+    ``
+  ];
+  for (const op of operationImports) {
+    const importPath = `./${op.path.replace(".ts", "")}`;
+    lines.push(`import { ${op.specName} } from '${importPath}';`);
+  }
+  lines.push(``);
+  lines.push(`export const operationRegistry = new OperationSpecRegistry();`);
+  lines.push(``);
+  for (const op of operationImports) {
+    lines.push(`operationRegistry.register(${op.specName});`);
+  }
+  lines.push(``);
+  return {
+    path: "registry.ts",
+    content: lines.join(`
+`),
+    type: "registry"
+  };
+}
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+export {
+  generateSchemas,
+  generateSchema,
+  generateRegistry,
+  generateOperations,
+  generateOperation
+};