@rexeus/typeweaver 0.0.3 → 0.0.4

package/dist/{cli-CteKWdCY.js → cli-Cz6q9I7F.js}

@@ -1,9 +1,12 @@
 import * as path from 'path';
 import path__default, { dirname } from 'path';
+import url, { fileURLToPath, pathToFileURL, URL as URL$1 } from 'url';
+import { Command } from 'commander';
 import fs, { realpathSync, statSync } from 'fs';
-import { HttpResponseDefinition, HttpOperationDefinition, HttpStatusCodeNameMap } from '@rexeus/typeweaver-core';
+import { PluginRegistry, PluginContextBuilder } from '@rexeus/typeweaver-gen';
+import TypesPlugin from '@rexeus/typeweaver-types';
+import { render } from 'ejs';
 import { createRequire, builtinModules } from 'module';
-import url, { fileURLToPath, pathToFileURL, URL as URL$1 } from 'url';
 import process3 from 'process';
 import os from 'os';
 import tty from 'tty';
@@ -11,203 +14,140 @@ import fs$1 from 'fs/promises';
 import assert2 from 'assert';
 import v8 from 'v8';
 import { format, inspect } from 'util';
-import { PluginRegistry, PluginContextBuilder } from '@rexeus/typeweaver-gen';
-import ejs from 'ejs';
-import TypesPlugin from '@rexeus/typeweaver-types';
-import { Command } from 'commander';
+import { HttpMethod, HttpStatusCode, HttpResponseDefinition, HttpOperationDefinition, HttpStatusCodeNameMap } from '@rexeus/typeweaver-core';
+import { z } from 'zod/v4';
 
-class InvalidSharedDirError extends Error {
-  constructor(explanation) {
-    super("Invalid shared dir");
-    this.explanation = explanation;
+var version = "0.0.4";
+var packageJson = {
+	version: version};
+
+class IndexFileGenerator {
+  constructor(templateDir) {
+    this.templateDir = templateDir;
+  }
+  generate(context) {
+    const templateFilePath = path__default.join(this.templateDir, "Index.ejs");
+    const template = fs.readFileSync(templateFilePath, "utf8");
+    const indexPaths = /* @__PURE__ */ new Set();
+    for (const generatedFile of context.getGeneratedFiles()) {
+      indexPaths.add(`./${generatedFile.replace(/\.ts$/, "")}`);
+    }
+    const content = render(template, {
+      indexPaths: Array.from(indexPaths).sort()
+    });
+    fs.writeFileSync(path__default.join(context.outputDir, "index.ts"), content);
   }
 }
 
-class InvalidSharedResponseDefinitionError extends Error {
-  constructor(fileName, dir, file, explanation) {
-    super("Invalid shared response definition");
-    this.fileName = fileName;
-    this.dir = dir;
-    this.file = file;
-    this.explanation = explanation;
+class PluginLoadingFailure extends Error {
+  constructor(pluginName, attempts) {
+    super(`Failed to load plugin '${pluginName}'`);
+    this.pluginName = pluginName;
+    this.attempts = attempts;
+    Object.setPrototypeOf(this, PluginLoadingFailure.prototype);
   }
 }
 
-class ResourceReader {
-  constructor(config) {
-    this.config = config;
+class PluginLoader {
+  constructor(registry, requiredPlugins, strategies = ["npm", "local"]) {
+    this.registry = registry;
+    this.requiredPlugins = requiredPlugins;
+    this.strategies = strategies;
   }
-  async getResources() {
-    const contents = fs.readdirSync(this.config.sourceDir, {
-      withFileTypes: true
-    });
-    const result = {
-      entityResources: {},
-      sharedResponseResources: []
-    };
-    const sharedDefinitions = contents.find(
-      (content) => content.name === "shared"
-    );
-    if (sharedDefinitions) {
-      if (!sharedDefinitions.isDirectory()) {
-        throw new InvalidSharedDirError("'shared' is a file, not a directory");
-      }
-      result.sharedResponseResources = await this.getSharedResponseResources();
-      console.info(
-        `Found '${result.sharedResponseResources.length}' shared responses`
-      );
-    } else {
-      console.info("No 'shared' directory found");
+  /**
+   * Load all plugins from configuration
+   */
+  async loadPlugins(config) {
+    for (const requiredPlugin of this.requiredPlugins) {
+      this.registry.register(requiredPlugin);
     }
-    for (const content of contents) {
-      if (!content.isDirectory()) {
-        console.info(`Skipping '${content.name}' as it is not a directory`);
-        continue;
-      }
-      if (content.name === "shared") {
-        continue;
-      }
-      const entityName = content.name;
-      const entitySourceDir = path__default.join(this.config.sourceDir, entityName);
-      const operationResources = await this.getEntityOperationResources(
-        entitySourceDir,
-        entityName
-      );
-      result.entityResources[entityName] = operationResources;
-      console.info(
-        `Found '${operationResources.length}' operation definitions for entity '${entityName}'`
-      );
+    if (!config?.plugins) {
+      return;
     }
-    return result;
-  }
-  async getSharedResponseResources() {
-    const sharedContents = fs.readdirSync(this.config.sharedSourceDir, {
-      withFileTypes: true
-    });
-    const sharedResponseResources = [];
-    for (const content of sharedContents) {
-      if (!content.isFile()) {
-        console.info(`Skipping '${content.name}' as it is not a file`);
-        continue;
-      }
-      const sourceFileName = content.name;
-      const sourceFile = path__default.join(this.config.sharedSourceDir, sourceFileName);
-      const definition = await import(sourceFile);
-      if (!definition.default) {
-        console.info(
-          `Skipping '${sourceFile}' as it does not have a default export`
-        );
-        continue;
-      }
-      if (!(definition.default instanceof HttpResponseDefinition)) {
-        console.info(
-          `Skipping '${sourceFile}' as it is not an instance of HttpResponseDefinition`
-        );
-        continue;
+    const successful = [];
+    for (const plugin of config.plugins) {
+      let result;
+      if (typeof plugin === "string") {
+        result = await this.loadPlugin(plugin);
+      } else {
+        result = await this.loadPlugin(plugin[0]);
       }
-      if (!definition.default.isShared) {
-        throw new InvalidSharedResponseDefinitionError(
-          sourceFileName,
-          this.config.sharedSourceDir,
-          sourceFile,
-          "'isShared' property is not set to 'true'"
+      if (result.success === false) {
+        throw new PluginLoadingFailure(
+          result.error.pluginName,
+          result.error.attempts
         );
       }
-      const outputDir = this.config.sharedOutputDir;
-      const outputFileName = `${definition.default.name}Response.ts`;
-      const outputFile = path__default.join(outputDir, outputFileName);
-      sharedResponseResources.push({
-        ...definition.default,
-        isShared: true,
-        sourceDir: this.config.sharedSourceDir,
-        sourceFile,
-        sourceFileName,
-        outputFile,
-        outputFileName,
-        outputDir
-      });
+      successful.push(result.value);
+      this.registry.register(result.value.plugin);
     }
-    return sharedResponseResources;
+    this.reportSuccessfulLoads(successful);
   }
-  async getEntityOperationResources(sourceDir, entityName) {
-    const contents = fs.readdirSync(sourceDir, {
-      withFileTypes: true
-    });
-    const definitions = [];
-    for (const content of contents) {
-      if (!content.isFile()) {
-        console.info(`Skipping '${content.name}' as it is not a file`);
-        continue;
-      }
-      const sourceFileName = content.name;
-      const sourceFile = path__default.join(sourceDir, sourceFileName);
-      const definition = await import(sourceFile);
-      if (!definition.default) {
-        console.info(
-          `Skipping '${sourceFile}' as it does not have a default export`
-        );
-        continue;
+  /**
+   * Load a plugin from a string identifier
+   */
+  async loadPlugin(pluginName) {
+    const possiblePaths = this.generatePluginPaths(pluginName);
+    const attempts = [];
+    for (const possiblePath of possiblePaths) {
+      try {
+        const pluginPackage = await import(possiblePath);
+        if (pluginPackage.default) {
+          return {
+            success: true,
+            value: {
+              plugin: new pluginPackage.default(),
+              source: possiblePath
+            }
+          };
+        }
+        attempts.push({
+          path: possiblePath,
+          error: "No default export found"
+        });
+      } catch (error) {
+        attempts.push({
+          path: possiblePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
-      if (!(definition.default instanceof HttpOperationDefinition)) {
-        console.info(
-          `Skipping '${sourceFile}' as it is not an instance of HttpOperationDefinition`
-        );
-        continue;
+    }
+    return {
+      success: false,
+      error: {
+        pluginName,
+        attempts
       }
-      const { operationId } = definition.default;
-      const outputDir = path__default.join(this.config.outputDir, entityName);
-      const outputRequestFileName = `${operationId}Request.ts`;
-      const outputRequestFile = path__default.join(outputDir, outputRequestFileName);
-      const outputResponseFileName = `${operationId}Response.ts`;
-      const outputResponseFile = path__default.join(outputDir, outputResponseFileName);
-      const outputRequestValidationFileName = `${operationId}RequestValidator.ts`;
-      const outputRequestValidationFile = path__default.join(
-        outputDir,
-        outputRequestValidationFileName
-      );
-      const outputResponseValidationFileName = `${operationId}ResponseValidator.ts`;
-      const outputResponseValidationFile = path__default.join(
-        outputDir,
-        outputResponseValidationFileName
-      );
-      const outputClientFileName = `${operationId}Client.ts`;
-      const outputClientFile = path__default.join(outputDir, outputClientFileName);
-      const operationResource = {
-        sourceDir,
-        sourceFile,
-        sourceFileName,
-        definition: {
-          ...definition.default,
-          responses: []
-        },
-        outputDir,
-        entityName,
-        outputRequestFile,
-        outputResponseFile,
-        outputResponseValidationFile,
-        outputRequestValidationFile,
-        outputRequestFileName,
-        outputRequestValidationFileName,
-        outputResponseFileName,
-        outputResponseValidationFileName,
-        outputClientFile,
-        outputClientFileName
-      };
-      if (!definition.default.responses) {
-        throw new Error(
-          `Operation '${operationId}' does not have any responses`
-        );
+    };
+  }
+  /**
+   * Generate possible plugin paths based on configured strategies
+   */
+  generatePluginPaths(pluginName) {
+    const paths = [];
+    for (const strategy of this.strategies) {
+      switch (strategy) {
+        case "npm":
+          paths.push(`@rexeus/typeweaver-${pluginName}`);
+          paths.push(`@rexeus/${pluginName}`);
+          break;
+        case "local":
+          paths.push(pluginName);
+          break;
       }
-      for (const response of definition.default.responses) {
-        const extendedResponse = {
-          ...response,
-          statusCodeName: HttpStatusCodeNameMap[response.statusCode]
-        };
-        operationResource.definition.responses.push(extendedResponse);
+    }
+    return paths;
+  }
+  /**
+   * Report successful plugin loads
+   */
+  reportSuccessfulLoads(successful) {
+    if (successful.length > 0) {
+      console.info(`Successfully loaded ${successful.length} plugin(s):`);
+      for (const result of successful) {
+        console.info(`  - ${result.plugin.name} (from ${result.source})`);
       }
-      definitions.push(operationResource);
     }
-    return definitions;
   }
 }
 
@@ -22453,11 +22393,11 @@ var { parsers, printers } = createParsersAndPrinters([
     printers: ["estree", "estree-json"]
   },
   {
-    importPlugin: () => import('./flow--vV0j3Y-.js'),
+    importPlugin: () => import('./flow-q2wMXrDa.js'),
     parsers: ["flow"]
   },
   {
-    importPlugin: () => import('./glimmer-B-ODUU1A.js'),
+    importPlugin: () => import('./glimmer-wgjvri6H.js'),
     parsers: ["glimmer"],
     printers: ["glimmer"]
   },
@@ -22472,7 +22412,7 @@ var { parsers, printers } = createParsersAndPrinters([
     printers: ["html"]
   },
   {
-    importPlugin: () => import('./markdown-Xi16tYTk.js'),
+    importPlugin: () => import('./markdown-Nz6Lc3gB.js'),
     parsers: ["markdown", "mdx", "remark"],
     printers: ["mdast"]
   },
@@ -22481,16 +22421,16 @@ var { parsers, printers } = createParsersAndPrinters([
     parsers: ["meriyah"]
   },
   {
-    importPlugin: () => import('./postcss-DdgOJBTx.js'),
+    importPlugin: () => import('./postcss-yEOijaXJ.js'),
     parsers: ["css", "less", "scss"],
     printers: ["postcss"]
   },
   {
-    importPlugin: () => import('./typescript-C4gnKzhB.js'),
+    importPlugin: () => import('./typescript-Cv79a1Qz.js'),
     parsers: ["typescript"]
   },
   {
-    importPlugin: () => import('./yaml-B0tq6Ttj.js'),
+    importPlugin: () => import('./yaml-DT3qlFoE.js'),
     parsers: ["yaml"],
     printers: ["yaml"]
   }
@@ -22810,7 +22750,6 @@ var debugApis = {
   printDocToString: withPlugins(printDocToString2),
   mockable: mockable_default
 };
-var src_default = index_exports;
 
 class Prettier {
   constructor(outputDir) {
@@ -22825,7 +22764,7 @@ class Prettier {
       if (content.isFile()) {
         const filePath = path__default.join(targetDir, content.name);
         const unformatted = fs.readFileSync(filePath, "utf8");
-        const formatted = await src_default.format(unformatted, {
+        const formatted = await format2(unformatted, {
           parser: "typescript"
         });
         fs.writeFileSync(filePath, formatted);
@@ -22836,133 +22775,823 @@ class Prettier {
   }
 }
 
-class IndexFileGenerator {
-  constructor(templateDir) {
-    this.templateDir = templateDir;
+class DuplicateOperationIdError extends Error {
+  constructor(operationId, firstFile, duplicateFile) {
+    super(
+      `Duplicate operation ID '${operationId}' found.
+  First defined in: \`${firstFile}\`
+  Duplicate found in: \`${duplicateFile}\``
+    );
+    this.operationId = operationId;
+    this.firstFile = firstFile;
+    this.duplicateFile = duplicateFile;
   }
-  generate(context) {
-    const templateFilePath = path__default.join(this.templateDir, "Index.ejs");
-    const template = fs.readFileSync(templateFilePath, "utf8");
-    const indexPaths = /* @__PURE__ */ new Set();
-    for (const generatedFile of context.getGeneratedFiles()) {
-      indexPaths.add(`./${generatedFile.replace(/\.ts$/, "")}`);
+}
+
+class DuplicateResponseNameError extends Error {
+  constructor(responseName, firstFile, duplicateFile) {
+    super(
+      `Duplicate response name '${responseName}' found.
+  First defined in: \`${firstFile}\`
+  Duplicate found in: \`${duplicateFile}\``
+    );
+    this.responseName = responseName;
+    this.firstFile = firstFile;
+    this.duplicateFile = duplicateFile;
+  }
+}
+
+class DuplicateRouteError extends Error {
+  constructor(path, method, firstOperationId, firstFile, duplicateOperationId, duplicateFile) {
+    super(
+      `Duplicate route '${method} ${path}' found.
+  First defined by operation '${firstOperationId}' in: \`${firstFile}\`
+  Duplicate defined by operation '${duplicateOperationId}' in: \`${duplicateFile}\``
+    );
+    this.path = path;
+    this.method = method;
+    this.firstOperationId = firstOperationId;
+    this.firstFile = firstFile;
+    this.duplicateOperationId = duplicateOperationId;
+    this.duplicateFile = duplicateFile;
+  }
+}
+
+class DefinitionRegistry {
+  operationIds = /* @__PURE__ */ new Map();
+  responseNames = /* @__PURE__ */ new Map();
+  routes = /* @__PURE__ */ new Map();
+  registerOperation(operation, sourceFile) {
+    const existingFile = this.operationIds.get(operation.operationId);
+    if (existingFile) {
+      throw new DuplicateOperationIdError(
+        operation.operationId,
+        existingFile,
+        sourceFile
+      );
     }
-    const content = ejs.render(template, {
-      indexPaths: Array.from(indexPaths).sort()
+    this.operationIds.set(operation.operationId, sourceFile);
+    const normalizedPath = this.normalizePath(operation.path);
+    const routeKey = `${operation.method} ${normalizedPath}`;
+    const existingRoute = this.routes.get(routeKey);
+    if (existingRoute) {
+      throw new DuplicateRouteError(
+        operation.path,
+        operation.method,
+        existingRoute.operationId,
+        existingRoute.file,
+        operation.operationId,
+        sourceFile
+      );
+    }
+    this.routes.set(routeKey, {
+      operationId: operation.operationId,
+      file: sourceFile
+    });
+  }
+  registerResponse(response, sourceFile) {
+    const existingFile = this.responseNames.get(response.name);
+    if (existingFile) {
+      throw new DuplicateResponseNameError(
+        response.name,
+        existingFile,
+        sourceFile
+      );
+    }
+    this.responseNames.set(response.name, sourceFile);
+  }
+  hasOperationId(operationId) {
+    return this.operationIds.has(operationId);
+  }
+  hasResponseName(name) {
+    return this.responseNames.has(name);
+  }
+  hasRoute(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const routeKey = `${method} ${normalizedPath}`;
+    return this.routes.has(routeKey);
+  }
+  getOperationFile(operationId) {
+    return this.operationIds.get(operationId);
+  }
+  getResponseFile(name) {
+    return this.responseNames.get(name);
+  }
+  getRouteInfo(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const routeKey = `${method} ${normalizedPath}`;
+    return this.routes.get(routeKey);
+  }
+  normalizePath(path) {
+    let paramIndex = 1;
+    return path.replace(/:([a-zA-Z0-9_]+)/g, () => {
+      return `:param${paramIndex++}`;
     });
-    fs.writeFileSync(path__default.join(context.outputDir, "index.ts"), content);
   }
 }
 
-class PluginLoadingFailure extends Error {
-  constructor(pluginName, attempts) {
-    super(`Failed to load plugin '${pluginName}'`);
-    this.pluginName = pluginName;
-    this.attempts = attempts;
-    Object.setPrototypeOf(this, PluginLoadingFailure.prototype);
+class EmptyResponseArrayError extends Error {
+  constructor(operationId, file) {
+    super(
+      `Operation '${operationId}' has no responses defined at \`${file}\`
+  Operations must have at least one response definition`
+    );
+    this.operationId = operationId;
+    this.file = file;
   }
 }
 
-class PluginLoader {
-  constructor(registry, requiredPlugins, strategies = ["npm", "local"]) {
-    this.registry = registry;
-    this.requiredPlugins = requiredPlugins;
-    this.strategies = strategies;
+class InvalidHttpMethodError extends Error {
+  constructor(operationId, method, file) {
+    const validMethods = Object.values(HttpMethod).join(", ");
+    super(
+      `Invalid HTTP method '${method}' in operation '${operationId}' at \`${file}\`
+  Valid methods: ${validMethods}`
+    );
+    this.operationId = operationId;
+    this.method = method;
+    this.file = file;
   }
-  /**
-   * Load all plugins from configuration
-   */
-  async loadPlugins(config) {
-    for (const requiredPlugin of this.requiredPlugins) {
-      this.registry.register(requiredPlugin);
+}
+
+class InvalidPathParameterError extends Error {
+  constructor(operationId, path, issue, file) {
+    super(
+      `Invalid path parameters in operation '${operationId}' at \`${file}\`
+  Path: ${path}
+  Issue: ${issue}`
+    );
+    this.operationId = operationId;
+    this.path = path;
+    this.issue = issue;
+    this.file = file;
+  }
+}
+
+class InvalidSchemaError extends Error {
+  constructor(schemaType, definitionName, context, file) {
+    const schemaRequirement = schemaType === "body" ? "Must be a Zod schema" : "Must be a Zod object schema";
+    super(
+      `Invalid ${schemaType} schema in ${context} '${definitionName}' at \`${file}\`. ${schemaRequirement}.`
+    );
+    this.schemaType = schemaType;
+    this.definitionName = definitionName;
+    this.context = context;
+    this.file = file;
+  }
+}
+
+class InvalidSchemaShapeError extends Error {
+  constructor(schemaType, definitionName, context, propertyName, invalidType, file) {
+    const allowedTypes = schemaType === "param" ? "string-based types (ZodString, ZodLiteral<string>, ZodEnum) or ZodOptional of these types" : "string-based types (ZodString, ZodLiteral<string>, ZodEnum), ZodOptional, or ZodArray of these types";
+    super(
+      `Invalid ${schemaType} schema shape in ${context} '${definitionName}' at \`${file}\`
+  Property '${propertyName}' has invalid type: ${invalidType}
+  Allowed types: ${allowedTypes}`
+    );
+    this.schemaType = schemaType;
+    this.definitionName = definitionName;
+    this.context = context;
+    this.propertyName = propertyName;
+    this.invalidType = invalidType;
+    this.file = file;
+  }
+}
+
+class InvalidStatusCodeError extends Error {
+  constructor(statusCode, responseName, file) {
+    const validStatusCodes = Object.values(HttpStatusCode).join(", ");
+    super(
+      `Invalid status code '${statusCode}' in response '${responseName}' at \`${file}\`
+  Valid status codes: ${validStatusCodes}`
+    );
+    this.statusCode = statusCode;
+    this.responseName = responseName;
+    this.file = file;
+  }
+}
+
+class MissingRequiredFieldError extends Error {
+  constructor(entityType, entityName, missingField, file) {
+    super(
+      `Missing required field '${missingField}' in ${entityType} '${entityName}' at \`${file}\``
+    );
+    this.entityType = entityType;
+    this.entityName = entityName;
+    this.missingField = missingField;
+    this.file = file;
+  }
+}
+
+class DefinitionValidator {
+  registry;
+  constructor(registry) {
+    this.registry = registry ?? new DefinitionRegistry();
+  }
+  validateOperation(operation, sourceFile) {
+    this.registry.registerOperation(operation, sourceFile);
+    this.validateOperationRequiredFields(operation, sourceFile);
+    this.validateHttpMethod(operation, sourceFile);
+    if (operation.request) {
+      this.validateRequestSchemas(operation, sourceFile);
+    }
+    this.validateOperationResponses(operation, sourceFile);
+    this.validatePathParameters(operation, sourceFile);
+  }
+  validateResponse(response, sourceFile) {
+    this.registry.registerResponse(response, sourceFile);
+    this.validateResponseRequiredFields(response, sourceFile);
+    this.validateStatusCode(response, sourceFile);
+    this.validateResponseSchemas(response, sourceFile);
+  }
+  validateOperationRequiredFields(operation, sourceFile) {
+    if (!operation.operationId) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        "unknown",
+        "operationId",
+        sourceFile
+      );
     }
-    if (!config?.plugins) {
-      return;
+    if (!operation.path) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        operation.operationId,
+        "path",
+        sourceFile
+      );
     }
-    const successful = [];
-    for (const plugin of config.plugins) {
-      let result;
-      if (typeof plugin === "string") {
-        result = await this.loadPlugin(plugin);
-      } else {
-        result = await this.loadPlugin(plugin[0]);
+    if (!operation.method) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        operation.operationId,
+        "method",
+        sourceFile
+      );
+    }
+    if (!operation.summary) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        operation.operationId,
+        "summary",
+        sourceFile
+      );
+    }
+  }
+  validateHttpMethod(operation, sourceFile) {
+    const validMethods = Object.values(HttpMethod);
+    if (!validMethods.includes(operation.method)) {
+      throw new InvalidHttpMethodError(
+        operation.operationId,
+        operation.method,
+        sourceFile
+      );
+    }
+  }
+  validateRequestSchemas(operation, sourceFile) {
+    const request = operation.request;
+    if (request.header) {
+      this.validateSchema(
+        request.header,
+        "header",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+    if (request.query) {
+      this.validateSchema(
+        request.query,
+        "query",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+    if (request.body) {
+      this.validateSchema(
+        request.body,
+        "body",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+    if (request.param) {
+      this.validateSchema(
+        request.param,
+        "param",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+  }
+  validateOperationResponses(operation, sourceFile) {
+    if (!operation.responses || operation.responses.length === 0) {
+      throw new EmptyResponseArrayError(operation.operationId, sourceFile);
+    }
+    for (const response of operation.responses) {
+      if (response instanceof HttpResponseDefinition) {
+        continue;
       }
-      if (result.success === false) {
-        throw new PluginLoadingFailure(
-          result.error.pluginName,
-          result.error.attempts
+      this.validateResponse(response, sourceFile);
+    }
+  }
+  validateResponseRequiredFields(response, sourceFile) {
+    if (!response.name) {
+      throw new MissingRequiredFieldError(
+        "response",
+        "unknown",
+        "name",
+        sourceFile
+      );
+    }
+    if (response.statusCode === void 0 || response.statusCode === null) {
+      throw new MissingRequiredFieldError(
+        "response",
+        response.name,
+        "statusCode",
+        sourceFile
+      );
+    }
+    if (!response.description) {
+      throw new MissingRequiredFieldError(
+        "response",
+        response.name,
+        "description",
+        sourceFile
+      );
+    }
+  }
+  validateStatusCode(response, sourceFile) {
+    const validStatusCodes = Object.values(HttpStatusCode);
+    if (!validStatusCodes.includes(response.statusCode)) {
+      throw new InvalidStatusCodeError(
+        response.statusCode,
+        response.name,
+        sourceFile
+      );
+    }
+  }
+  validateResponseSchemas(response, sourceFile) {
+    if (response.header) {
+      this.validateSchema(
+        response.header,
+        "header",
+        response.name,
+        "response",
+        sourceFile
+      );
+    }
+    if (response.body) {
+      this.validateSchema(
+        response.body,
+        "body",
+        response.name,
+        "response",
+        sourceFile
+      );
+    }
+  }
+  validateSchema(schema, schemaType, definitionName, context, sourceFile) {
+    if (schemaType === "body") {
+      if (!(schema instanceof z.ZodType)) {
+        throw new InvalidSchemaError(
+          schemaType,
+          definitionName,
+          context,
+          sourceFile
         );
       }
-      successful.push(result.value);
-      this.registry.register(result.value.plugin);
+      return;
+    }
+    if (!(schema instanceof z.ZodObject)) {
+      throw new InvalidSchemaError(
+        schemaType,
+        definitionName,
+        context,
+        sourceFile
+      );
+    }
+    if (schemaType === "param") {
+      this.validateParamShape(schema, definitionName, sourceFile);
+    } else {
+      this.validateHeaderOrQueryShape(
+        schema,
+        schemaType,
+        definitionName,
+        context,
+        sourceFile
+      );
     }
-    this.reportSuccessfulLoads(successful);
   }
-  /**
-   * Load a plugin from a string identifier
-   */
-  async loadPlugin(pluginName) {
-    const possiblePaths = this.generatePluginPaths(pluginName);
-    const attempts = [];
-    for (const possiblePath of possiblePaths) {
-      try {
-        const pluginPackage = await import(possiblePath);
-        if (pluginPackage.default) {
-          return {
-            success: true,
-            value: {
-              plugin: new pluginPackage.default(),
-              source: possiblePath
-            }
-          };
+  validatePathParameters(operation, sourceFile) {
+    const pathParamMatches = operation.path.matchAll(/:([a-zA-Z0-9_]+)/g);
+    const pathParamsSet = /* @__PURE__ */ new Set();
+    for (const match of pathParamMatches) {
+      const paramName = match[1];
+      if (pathParamsSet.has(paramName)) {
+        throw new InvalidPathParameterError(
+          operation.operationId,
+          operation.path,
+          `Duplicate parameter name '${paramName}' in path`,
+          sourceFile
+        );
+      }
+      pathParamsSet.add(paramName);
+    }
+    const paramSchema = operation.request?.param;
+    if (pathParamsSet.size > 0 && !paramSchema) {
+      throw new InvalidPathParameterError(
+        operation.operationId,
+        operation.path,
+        `Path contains parameters [${Array.from(pathParamsSet).join(", ")}] but request.param is not defined`,
+        sourceFile
+      );
+    }
+    if (paramSchema && paramSchema instanceof z.ZodObject) {
+      const paramShape = paramSchema.shape;
+      const paramKeys = new Set(Object.keys(paramShape));
+      for (const pathParam of pathParamsSet) {
+        if (!paramKeys.has(pathParam)) {
+          throw new InvalidPathParameterError(
+            operation.operationId,
+            operation.path,
+            `Path parameter ':${pathParam}' is not defined in request.param`,
+            sourceFile
+          );
+        }
+      }
+      for (const paramKey of paramKeys) {
+        if (!pathParamsSet.has(paramKey)) {
+          throw new InvalidPathParameterError(
+            operation.operationId,
+            operation.path,
+            `Parameter '${paramKey}' is defined in request.param but not used in the path`,
+            sourceFile
+          );
         }
-        attempts.push({
-          path: possiblePath,
-          error: "No default export found"
-        });
-      } catch (error) {
-        attempts.push({
-          path: possiblePath,
-          error: error instanceof Error ? error.message : String(error)
-        });
       }
     }
-    return {
-      success: false,
-      error: {
-        pluginName,
-        attempts
+  }
+  validateHeaderOrQueryShape(schema, schemaType, definitionName, context, sourceFile) {
+    const shape = schema.shape;
+    for (const [propName, propSchema] of Object.entries(shape)) {
+      if (!this.isValidHeaderOrQueryValue(propSchema)) {
+        const typeName = this.getZodTypeName(propSchema);
+        throw new InvalidSchemaShapeError(
+          schemaType,
+          definitionName,
+          context,
+          propName,
+          typeName,
+          sourceFile
+        );
+      }
+    }
+  }
+  validateParamShape(schema, operationId, sourceFile) {
+    const shape = schema.shape;
+    for (const [propName, propSchema] of Object.entries(shape)) {
+      if (!this.isValidParamValue(propSchema)) {
+        const typeName = this.getZodTypeName(propSchema);
+        throw new InvalidSchemaShapeError(
+          "param",
+          operationId,
+          "request",
+          propName,
+          typeName,
+          sourceFile
+        );
       }
+    }
+  }
+  isValidHeaderOrQueryValue(schema) {
+    if (this.isStringBasedType(schema)) {
+      return true;
+    }
+    if (schema instanceof z.ZodOptional) {
+      return this.isValidHeaderOrQueryValue(schema.unwrap());
+    }
+    if (schema instanceof z.ZodArray) {
+      return this.isStringBasedType(schema.element);
+    }
+    return false;
+  }
+  isValidParamValue(schema) {
+    if (this.isStringBasedType(schema)) {
+      return true;
+    }
+    if (schema instanceof z.ZodOptional) {
+      return this.isStringBasedType(schema.unwrap());
+    }
+    return false;
+  }
+  isStringBasedType(schema) {
+    if (schema instanceof z.ZodString) {
+      return true;
+    }
+    if (schema instanceof z.ZodLiteral && typeof schema.value === "string") {
+      return true;
+    }
+    if (schema instanceof z.ZodEnum) {
+      return true;
+    }
+    const typeName = schema.constructor.name;
+    const stringFormatTypes = [
+      "ZodULID",
+      "ZodUUID",
+      "ZodUUIDv4",
+      "ZodUUIDv7",
+      "ZodUUIDv8",
+      "ZodEmail",
+      "ZodURL",
+      "ZodCUID",
+      "ZodCUID2",
+      "ZodNanoID",
+      "ZodBase64",
+      "ZodBase64URL",
+      "ZodEmoji",
+      "ZodIPv4",
+      "ZodIPv6",
+      "ZodCIDRv4",
+      "ZodCIDRv6",
+      "ZodE164",
+      "ZodJWT",
+      "ZodASCII",
+      "ZodUTF8",
+      "ZodLowercase",
+      "ZodGUID",
+      "ZodISODate",
+      "ZodISOTime",
+      "ZodISODateTime",
+      "ZodISODuration"
+    ];
+    if (stringFormatTypes.includes(typeName)) {
+      return true;
+    }
+    if (schema._def && schema._def.typeName && schema._def.typeName.includes("String")) {
+      return true;
+    }
+    return false;
+  }
+  getZodTypeName(schema) {
+    const typeName = schema.constructor.name;
+    if (schema instanceof z.ZodOptional) {
+      return `ZodOptional<${this.getZodTypeName(schema.unwrap())}>`;
+    }
+    if (schema instanceof z.ZodArray) {
+      return `ZodArray<${this.getZodTypeName(schema.element)}>`;
+    }
+    if (schema instanceof z.ZodLiteral) {
+      return `ZodLiteral<${typeof schema.value}>`;
+    }
+    return typeName;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+}
+
+class InvalidSharedDirError extends Error {
+  constructor(explanation) {
+    super("Invalid shared dir");
+    this.explanation = explanation;
+  }
+}
+
+class ResourceReader {
+  constructor(config) {
+    this.config = config;
+  }
+  async getResources() {
+    const contents = fs.readdirSync(this.config.sourceDir, {
+      withFileTypes: true
+    });
+    const result = {
+      entityResources: {},
+      sharedResponseResources: []
     };
+    const validator = new DefinitionValidator();
+    if (fs.existsSync(this.config.sharedSourceDir)) {
+      const sharedStats = fs.statSync(this.config.sharedSourceDir);
+      if (!sharedStats.isDirectory()) {
+        throw new InvalidSharedDirError(
+          `'${this.config.sharedSourceDir}' is a file, not a directory`
+        );
+      }
+      result.sharedResponseResources = await this.getSharedResponseResources(validator);
+      console.info(
+        `Found '${result.sharedResponseResources.length}' shared responses in '${this.config.sharedSourceDir}'`
+      );
+    } else {
+      console.info(
+        `No shared directory found at '${this.config.sharedSourceDir}'`
+      );
+    }
+    const normalizedSharedPath = path__default.resolve(this.config.sharedSourceDir);
+    for (const content of contents) {
+      if (!content.isDirectory()) {
+        console.info(`Skipping '${content.name}' as it is not a directory`);
+        continue;
+      }
+      const entityName = content.name;
+      const entitySourceDir = path__default.resolve(this.config.sourceDir, entityName);
+      if (entitySourceDir === normalizedSharedPath || normalizedSharedPath.startsWith(entitySourceDir + path__default.sep)) {
+        console.info(
+          `Skipping '${content.name}' as it is or contains the shared directory`
+        );
+        continue;
+      }
+      const responseResources = await this.getEntityResponseResources(
+        entitySourceDir,
+        entityName,
+        validator
+      );
+      const operationResources = await this.getEntityOperationResources(
+        entitySourceDir,
+        entityName,
+        validator,
+        [...result.sharedResponseResources, ...responseResources]
+      );
+      result.entityResources[entityName] = {
+        operations: operationResources,
+        responses: responseResources
+      };
+      console.info(
+        `Found '${operationResources.length}' operation definitions for entity '${entityName}'`
+      );
+      if (responseResources.length > 0) {
+        console.info(
+          `Found '${responseResources.length}' response definitions for entity '${entityName}'`
+        );
+      }
+    }
+    return result;
   }
-  /**
-   * Generate possible plugin paths based on configured strategies
-   */
-  generatePluginPaths(pluginName) {
-    const paths = [];
-    for (const strategy of this.strategies) {
-      switch (strategy) {
-        case "npm":
-          paths.push(`@rexeus/typeweaver-${pluginName}`);
-          paths.push(`@rexeus/${pluginName}`);
-          break;
-        case "local":
-          paths.push(pluginName);
-          break;
+  scanDirectoryRecursively(dir) {
+    const files = [];
+    const contents = fs.readdirSync(dir, { withFileTypes: true });
+    for (const content of contents) {
+      const fullPath = path__default.join(dir, content.name);
+      if (content.isDirectory()) {
+        files.push(...this.scanDirectoryRecursively(fullPath));
+      } else if (content.isFile() && content.name.endsWith(".ts")) {
+        files.push(fullPath);
       }
     }
-    return paths;
+    return files;
   }
-  /**
-   * Report successful plugin loads
-   */
-  reportSuccessfulLoads(successful) {
-    if (successful.length > 0) {
-      console.info(`Successfully loaded ${successful.length} plugin(s):`);
-      for (const result of successful) {
-        console.info(`  - ${result.plugin.name} (from ${result.source})`);
+  async getSharedResponseResources(validator) {
+    const files = this.scanDirectoryRecursively(this.config.sharedSourceDir);
+    const sharedResponseResources = [];
+    for (const sourceFile of files) {
+      const sourceFileName = path__default.basename(sourceFile);
+      const definition = await import(sourceFile);
+      if (!definition.default) {
+        console.info(
+          `Skipping '${sourceFile}' as it does not have a default export`
+        );
+        continue;
+      }
+      if (!(definition.default instanceof HttpResponseDefinition)) {
+        console.info(
+          `Skipping '${sourceFile}' as it is not an instance of HttpResponseDefinition`
+        );
+        continue;
+      }
+      validator.validateResponse(definition.default, sourceFile);
+      const outputDir = this.config.sharedOutputDir;
+      const outputFileName = `${definition.default.name}Response.ts`;
+      const outputFile = path__default.join(outputDir, outputFileName);
+      sharedResponseResources.push({
+        ...definition.default,
+        sourceDir: this.config.sharedSourceDir,
+        sourceFile,
+        sourceFileName,
+        outputFile,
+        outputFileName,
+        outputDir
+      });
+    }
+    return sharedResponseResources;
+  }
+  async getEntityOperationResources(sourceDir, entityName, validator, referencedResponses) {
+    const files = this.scanDirectoryRecursively(sourceDir);
+    const definitions = [];
+    for (const sourceFile of files) {
+      const sourceFileName = path__default.basename(sourceFile);
+      const definition = await import(sourceFile);
+      if (!definition.default) {
+        console.info(
+          `Skipping '${sourceFile}' as it does not have a default export`
+        );
+        continue;
+      }
+      if (!(definition.default instanceof HttpOperationDefinition)) {
+        console.info(
+          `Skipping '${sourceFile}' as it is not an instance of HttpOperationDefinition`
+        );
+        continue;
+      }
+      validator.validateOperation(definition.default, sourceFile);
+      const { operationId } = definition.default;
+      const outputDir = path__default.join(this.config.outputDir, entityName);
+      const outputRequestFileName = `${operationId}Request.ts`;
+      const outputRequestFile = path__default.join(outputDir, outputRequestFileName);
+      const outputResponseFileName = `${operationId}Response.ts`;
+      const outputResponseFile = path__default.join(outputDir, outputResponseFileName);
+      const outputRequestValidationFileName = `${operationId}RequestValidator.ts`;
+      const outputRequestValidationFile = path__default.join(
+        outputDir,
+        outputRequestValidationFileName
+      );
+      const outputResponseValidationFileName = `${operationId}ResponseValidator.ts`;
+      const outputResponseValidationFile = path__default.join(
+        outputDir,
+        outputResponseValidationFileName
+      );
+      const outputClientFileName = `${operationId}Client.ts`;
+      const outputClientFile = path__default.join(outputDir, outputClientFileName);
+      const operationResource = {
+        sourceDir,
+        sourceFile,
+        sourceFileName,
+        definition: {
+          ...definition.default,
+          responses: []
+        },
+        outputDir,
+        entityName,
+        outputRequestFile,
+        outputResponseFile,
+        outputResponseValidationFile,
+        outputRequestValidationFile,
+        outputRequestFileName,
+        outputRequestValidationFileName,
+        outputResponseFileName,
+        outputResponseValidationFileName,
+        outputClientFile,
+        outputClientFileName
+      };
+      if (!definition.default.responses) {
+        throw new Error(
+          `Operation '${operationId}' does not have any responses`
+        );
+      }
+      for (const response of definition.default.responses) {
+        if (referencedResponses.some((ref) => ref.name === response.name)) {
+          const referencedResponse = {
+            ...response,
+            statusCodeName: HttpStatusCodeNameMap[response.statusCode],
+            isReference: true
+          };
+          operationResource.definition.responses.push(referencedResponse);
+        } else {
+          const extendedResponse = {
+            ...response,
+            statusCodeName: HttpStatusCodeNameMap[response.statusCode],
+            isReference: false
+          };
+          operationResource.definition.responses.push(extendedResponse);
+        }
+      }
+      definitions.push(operationResource);
+    }
+    return definitions;
+  }
+  async getEntityResponseResources(sourceDir, entityName, validator) {
+    const files = this.scanDirectoryRecursively(sourceDir);
+    const responseResources = [];
+    for (const sourceFile of files) {
+      const sourceFileName = path__default.basename(sourceFile);
+      const definition = await import(sourceFile);
+      if (!definition.default) {
+        continue;
+      }
+      if (!(definition.default instanceof HttpResponseDefinition)) {
+        continue;
       }
+      validator.validateResponse(definition.default, sourceFile);
+      const outputFileName = `${definition.default.name}Response.ts`;
+      const outputFile = path__default.join(
+        this.config.outputDir,
+        entityName,
+        outputFileName
+      );
+      responseResources.push({
+        ...definition.default,
+        sourceDir,
+        sourceFile,
+        sourceFileName,
+        outputFile,
+        outputFileName,
+        outputDir: path__default.join(this.config.outputDir, entityName),
+        entityName
+      });
     }
+    return responseResources;
   }
 }
 
@@ -22976,6 +23605,8 @@ class Generator {
   indexFileGenerator;
   resourceReader = null;
   prettier = null;
+  inputDir = "";
+  sharedInputDir = "";
   outputDir = "";
   sourceDir = "";
   sharedSourceDir = "";
@@ -22991,13 +23622,22 @@ class Generator {
    */
   async generate(definitionDir, outputDir, config) {
     console.info("Starting generation...");
-    this.initializeDirectories(definitionDir, outputDir);
+    this.initializeDirectories(definitionDir, outputDir, config?.shared);
     if (config?.clean ?? true) {
       console.info("Cleaning output directory...");
       fs.rmSync(this.outputDir, { recursive: true, force: true });
     }
     fs.mkdirSync(this.outputDir, { recursive: true });
     fs.mkdirSync(this.sharedOutputDir, { recursive: true });
+    console.info(
+      `Copying definitions from '${this.inputDir}' to '${this.sourceDir}'...`
+    );
+    fs.cpSync(this.inputDir, this.sourceDir, {
+      recursive: true,
+      filter: (src) => {
+        return src.endsWith(".ts") || src.endsWith(".js") || src.endsWith(".json") || src.endsWith(".mjs") || src.endsWith(".cjs") || fs.statSync(src).isDirectory();
+      }
+    });
     await this.pluginLoader.loadPlugins(config);
     this.resourceReader = new ResourceReader({
       sourceDir: this.sourceDir,
@@ -23055,22 +23695,24 @@ class Generator {
       `Generated files: ${this.contextBuilder.getGeneratedFiles().length}`
     );
   }
-  initializeDirectories(definitionDir, outputDir) {
-    this.sourceDir = definitionDir;
+  initializeDirectories(definitionDir, outputDir, sharedDir) {
+    this.inputDir = definitionDir;
+    this.sharedInputDir = sharedDir ?? path__default.join(definitionDir, "shared");
     this.outputDir = outputDir;
-    this.sharedSourceDir = path__default.join(definitionDir, "shared");
     this.sharedOutputDir = path__default.join(outputDir, "shared");
+    this.sourceDir = path__default.join(this.outputDir, "definition");
+    const inputToSharedDirRelative = path__default.relative(
+      this.inputDir,
+      this.sharedInputDir
+    );
+    this.sharedSourceDir = path__default.join(this.sourceDir, inputToSharedDirRelative);
   }
 }
 
-var version = "0.0.3";
-var packageJson = {
-	version: version};
-
 const program = new Command();
 const execDir = process.cwd();
 program.name("@rexeus/typeweaver").description("Type-safe API framework with code generation for TypeScript").version(packageJson.version);
-program.command("generate").description("Generate types, validators, and clients from API definitions").option("-i, --input <inputDir>", "path to definition directory").option("-o, --output <outputDir>", "output directory for generated files").option("-c, --config <configFile>", "path to configuration file").option("-p, --plugins <plugins>", "comma-separated list of plugins to use").option("--prettier", "format generated code with Prettier (default: true)").option("--no-prettier", "disable Prettier formatting").option("--clean", "clean output directory before generation (default: true)").option("--no-clean", "disable cleaning output directory").action(async (options) => {
+program.command("generate").description("Generate types, validators, and clients from API definitions").option("-i, --input <inputDir>", "path to definition directory").option("-o, --output <outputDir>", "output directory for generated files").option("-s, --shared <path>", "path to shared definitions directory").option("-c, --config <configFile>", "path to configuration file").option("-p, --plugins <plugins>", "comma-separated list of plugins to use").option("--prettier", "format generated code with Prettier (default: true)").option("--no-prettier", "disable Prettier formatting").option("--clean", "clean output directory before generation (default: true)").option("--no-clean", "disable cleaning output directory").action(async (options) => {
   let config = {};
   if (options.config) {
     const configPath = path__default.isAbsolute(options.config) ? options.config : path__default.join(execDir, options.config);
@@ -23087,6 +23729,7 @@ program.command("generate").description("Generate types, validators, and clients
   }
   const inputDir = options.input ?? config.input;
   const outputDir = options.output ?? config.output;
+  const sharedDir = options.shared ?? config.shared;
   if (!inputDir) {
     throw new Error(
       "No input directory provided. Use --input or specify in config file."
@@ -23099,9 +23742,11 @@ program.command("generate").description("Generate types, validators, and clients
   }
   const resolvedInputDir = path__default.isAbsolute(inputDir) ? inputDir : path__default.join(execDir, inputDir);
   const resolvedOutputDir = path__default.isAbsolute(outputDir) ? outputDir : path__default.join(execDir, outputDir);
+  const resolvedSharedDir = sharedDir ? path__default.isAbsolute(sharedDir) ? sharedDir : path__default.join(execDir, sharedDir) : void 0;
   const finalConfig = {
     input: resolvedInputDir,
     output: resolvedOutputDir,
+    shared: resolvedSharedDir,
     prettier: options.prettier ?? config.prettier ?? true,
     clean: options.clean ?? config.clean ?? true
   };
@@ -23113,7 +23758,7 @@ program.command("generate").description("Generate types, validators, and clients
   const generator = new Generator();
   return generator.generate(resolvedInputDir, resolvedOutputDir, finalConfig);
 });
-program.command("init").description("Initialize a new TypeWeaver project (coming soon)").action(() => {
+program.command("init").description("Initialize a new typeweaver project (coming soon)").action(() => {
   console.log("The init command is coming soon!");
 });
 program.parse(process.argv);