apiwork 0.0.0 → 0.0.3

package/dist/chunk-QGKZLUZR.js

@@ -0,0 +1,1151 @@
+import {
+  camelCase
+} from "./chunk-MWFEILAW.js";
+
+// src/utils/snake-case.ts
+function snakeCase(name) {
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
+}
+
+// src/utils/kebab-case.ts
+function kebabCase(name) {
+  return snakeCase(name).replace(/_/g, "-");
+}
+
+// src/utils/pascal-case.ts
+function pascalCase(name) {
+  return camelCase(name).replace(
+    /^[a-z]/,
+    (character) => character.toUpperCase()
+  );
+}
+
+// src/codegen/options.ts
+function resolveGenerateOptions(options) {
+  const {
+    fileCase = "kebab",
+    importExtension = "",
+    transformIdentifier = (identifier) => identifier
+  } = options;
+  return {
+    fileCase,
+    importExtension,
+    transformIdentifier
+  };
+}
+function formatFileName(name, fileCase) {
+  switch (fileCase) {
+    case "kebab":
+      return kebabCase(name);
+    case "camel":
+      return camelCase(name);
+    case "pascal":
+      return pascalCase(name);
+    case "snake":
+      return snakeCase(name);
+  }
+}
+function resolveDomainIdentifier(rawName, context) {
+  const scope = context.scopeIndex.get(rawName);
+  const source = scope === null || scope === void 0 ? "api" : "domain";
+  return context.options.transformIdentifier(pascalCase(rawName), source);
+}
+function resolveEndpointIdentifier(identifier, context) {
+  return context.options.transformIdentifier(identifier, "endpoint");
+}
+function resolveClientIdentifier(identifier, context) {
+  return context.options.transformIdentifier(identifier, "client");
+}
+
+// src/zod/mapper.ts
+var TYPE_MAP = {
+  binary: "z.string()",
+  boolean: "z.boolean()",
+  date: "z.iso.date()",
+  datetime: "z.iso.datetime()",
+  decimal: "z.number()",
+  integer: "z.number().int()",
+  number: "z.number()",
+  string: "z.string()",
+  time: "z.iso.time()",
+  unknown: "z.unknown()",
+  uuid: "z.uuid()"
+};
+var FORMAT_MAP = {
+  date: "z.iso.date()",
+  datetime: "z.iso.datetime()",
+  double: "z.number()",
+  email: "z.email()",
+  float: "z.number()",
+  hostname: "z.string()",
+  int32: "z.number().int()",
+  int64: "z.number().int()",
+  ipv4: "z.ipv4()",
+  ipv6: "z.ipv6()",
+  password: "z.string()",
+  url: "z.url()",
+  uuid: "z.uuid()"
+};
+function generateEnumSchema(_enum, context) {
+  const name = resolveDomainIdentifier(_enum.name, context);
+  const values = _enum.values.sort().map((value) => `'${value}'`).join(", ");
+  return `export const ${name}Schema = z.enum([${values}]);`;
+}
+function generateObjectSchema(type, context) {
+  const name = resolveDomainIdentifier(type.name, context);
+  const properties = [...type.shape].sort((a, b) => a.name.localeCompare(b.name)).map((param) => {
+    return `  ${param.name}: ${mapParamToZod(param, context)},`;
+  }).join("\n");
+  if (type.recursive) {
+    return `export const ${name}Schema: z.ZodType<${name}> = z.lazy(() => z.object({
+${properties}
+}));`;
+  }
+  if (type.extends.length > 0) {
+    const bases = type.extends.map(
+      (base) => `${resolveDomainIdentifier(base, context)}Schema`
+    );
+    if (bases.length === 1) {
+      if (properties.trim()) {
+        return `export const ${name}Schema = ${bases[0]}.merge(z.object({
+${properties}
+}));`;
+      }
+      return `export const ${name}Schema = ${bases[0]};`;
+    }
+    const merged = bases.join(".merge(") + ")".repeat(bases.length - 1);
+    if (properties.trim()) {
+      return `export const ${name}Schema = ${merged}.merge(z.object({
+${properties}
+}));`;
+    }
+    return `export const ${name}Schema = ${merged};`;
+  }
+  return `export const ${name}Schema = z.object({
+${properties}
+});`;
+}
+function generateUnionSchema(type, context) {
+  const name = resolveDomainIdentifier(type.name, context);
+  let unionCode;
+  if (type.discriminator) {
+    const variants = type.variants.map((variant) => {
+      const base = mapParamToZod(variant, context);
+      const tag = "tag" in variant ? variant.tag : null;
+      if (tag) {
+        return `${base}.extend({ ${type.discriminator}: z.literal('${tag}') })`;
+      }
+      return base;
+    });
+    unionCode = `z.discriminatedUnion('${type.discriminator}', [
+  ${variants.join(",\n  ")}
+])`;
+  } else {
+    const variants = type.variants.map(
+      (variant) => mapParamToZod(variant, context)
+    );
+    unionCode = `z.union([
+  ${variants.join(",\n  ")}
+])`;
+  }
+  if (type.recursive) {
+    return `export const ${name}Schema: z.ZodType<${name}> = z.lazy(() => ${unionCode});`;
+  }
+  return `export const ${name}Schema = ${unionCode};`;
+}
+function mapParamToZod(param, context) {
+  let base = mapParamBase(param, context);
+  base = applyModifiers(base, param);
+  return base;
+}
+function mapParamBase(param, context) {
+  switch (param.type) {
+    case "string":
+    case "integer":
+    case "number":
+    case "decimal":
+    case "boolean":
+    case "date":
+    case "datetime":
+    case "time":
+    case "uuid":
+    case "binary":
+      return mapScalar(param, context);
+    case "literal":
+      return mapLiteral(param);
+    case "array":
+      return mapArray(param, context);
+    case "record":
+      return mapRecord(param, context);
+    case "object":
+      return mapObject(param, context);
+    case "union":
+      return mapUnion(param, context);
+    case "reference":
+      return `${resolveDomainIdentifier(param.reference, context)}Schema`;
+    case "unknown":
+      return "z.unknown()";
+  }
+}
+function mapScalar(param, context) {
+  if (param.enum) {
+    return `${resolveDomainIdentifier(param.enum, context)}Schema`;
+  }
+  let base;
+  if (param.format) {
+    base = FORMAT_MAP[param.format] ?? TYPE_MAP[param.type] ?? "z.unknown()";
+  } else {
+    base = TYPE_MAP[param.type] ?? "z.unknown()";
+  }
+  if ("min" in param && param.min !== null && param.min !== void 0) {
+    base += `.min(${param.min})`;
+  }
+  if ("max" in param && param.max !== null && param.max !== void 0) {
+    base += `.max(${param.max})`;
+  }
+  return base;
+}
+function mapLiteral(param) {
+  if (param.value === null) {
+    return "z.null()";
+  }
+  if (typeof param.value === "string") {
+    return `z.literal('${param.value}')`;
+  }
+  return `z.literal(${param.value})`;
+}
+function mapArray(param, context) {
+  const items = param.of ? mapParamToZod(param.of, context) : "z.unknown()";
+  let base = `z.array(${items})`;
+  if (param.min !== null && param.min !== void 0) {
+    base += `.min(${param.min})`;
+  }
+  if (param.max !== null && param.max !== void 0) {
+    base += `.max(${param.max})`;
+  }
+  return base;
+}
+function mapRecord(param, context) {
+  const value = param.of ? mapParamToZod(param.of, context) : "z.unknown()";
+  return `z.record(z.string(), ${value})`;
+}
+function mapObject(param, context) {
+  if (param.shape.length === 0) {
+    return "z.record(z.string(), z.unknown())";
+  }
+  const properties = [...param.shape].sort((a, b) => a.name.localeCompare(b.name)).map((field) => {
+    const zodType = param.partial ? mapParamToZodWithoutOptional(field, context) : mapParamToZod(field, context);
+    return `${field.name}: ${zodType}`;
+  }).join(", ");
+  const base = `z.object({ ${properties} })`;
+  return param.partial ? `${base}.partial()` : base;
+}
+function mapUnion(param, context) {
+  if (param.discriminator) {
+    const variants2 = param.variants.map(
+      (variant) => mapParamToZod(variant, context)
+    );
+    return `z.discriminatedUnion('${param.discriminator}', [${variants2.join(", ")}])`;
+  }
+  const variants = param.variants.map(
+    (variant) => mapParamToZod(variant, context)
+  );
+  return `z.union([${variants.join(", ")}])`;
+}
+function applyModifiers(base, param) {
+  if (param.nullable && hasDefault(param)) {
+    return `${base}.nullable().default(${serializeDefault(param)})`;
+  }
+  if (hasDefault(param)) {
+    return `${base}.default(${serializeDefault(param)})`;
+  }
+  if (param.nullable && param.optional) {
+    return `${base}.nullable().optional()`;
+  }
+  if (param.optional) {
+    return `${base}.optional()`;
+  }
+  if (param.nullable) {
+    return `${base}.nullable()`;
+  }
+  return base;
+}
+function hasDefault(param) {
+  if (!("default" in param)) {
+    return false;
+  }
+  if (param.default === void 0) {
+    return false;
+  }
+  return true;
+}
+function serializeDefault(param) {
+  const value = "default" in param ? param.default : void 0;
+  if (value === null) {
+    return "null";
+  }
+  if (value === "") {
+    return "''";
+  }
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function mapParamToZodWithoutOptional(param, context) {
+  const base = mapParamBase(param, context);
+  if (param.nullable && hasDefault(param)) {
+    return `${base}.nullable().default(${serializeDefault(param)})`;
+  }
+  if (param.nullable) {
+    return `${base}.nullable()`;
+  }
+  if (hasDefault(param)) {
+    return `${base}.default(${serializeDefault(param)})`;
+  }
+  return base;
+}
+
+// src/codegen/references.ts
+function collectTypeReferences(types, enums) {
+  const references = /* @__PURE__ */ new Set();
+  const localNames = /* @__PURE__ */ new Set();
+  for (const _enum of enums) {
+    localNames.add(_enum.name);
+  }
+  for (const type of types) {
+    localNames.add(type.name);
+  }
+  for (const type of types) {
+    if (type.type === "object") {
+      for (const param of type.shape) {
+        collectParamReferences(param, references);
+      }
+    } else {
+      for (const variant of type.variants) {
+        collectParamReferences(variant, references);
+      }
+    }
+  }
+  for (const name of localNames) {
+    references.delete(name);
+  }
+  return references;
+}
+function collectParamReferences(param, references) {
+  switch (param.type) {
+    case "reference":
+      references.add(param.reference);
+      break;
+    case "array":
+      if (param.of) {
+        collectParamReferences(param.of, references);
+      }
+      break;
+    case "record":
+      if (param.of) {
+        collectParamReferences(param.of, references);
+      }
+      break;
+    case "object":
+      for (const field of param.shape) {
+        collectParamReferences(field, references);
+      }
+      break;
+    case "union":
+      for (const variant of param.variants) {
+        collectParamReferences(variant, references);
+      }
+      break;
+    case "string":
+    case "integer":
+    case "number":
+    case "decimal":
+    case "boolean":
+    case "date":
+    case "datetime":
+    case "time":
+    case "uuid":
+      if (param.enum) {
+        references.add(param.enum);
+      }
+      break;
+  }
+}
+
+// src/codegen/endpoint.ts
+function buildEndpoints(schema, scopeIndex, options, resolvedOptions) {
+  const files = /* @__PURE__ */ new Map();
+  const actionFiles = [];
+  const context = { options: resolvedOptions, scopeIndex };
+  traverseResources(schema.resources, [], actionFiles, options, context);
+  for (const actionFile of actionFiles) {
+    const content = buildActionFileContent(actionFile, options, context);
+    files.set(actionFile.filename, content);
+  }
+  if (actionFiles.length > 0) {
+    buildBarrelExports(actionFiles, files, resolvedOptions);
+  }
+  return files;
+}
+function buildActionFileContent(actionFile, options, context) {
+  const parts = [];
+  if (options.endpoints) {
+    parts.push("import type { Operation } from 'sorbus';");
+    parts.push("import * as z from 'zod';");
+  } else if (options.zod) {
+    parts.push("import * as z from 'zod';");
+  }
+  const contractImports = buildContractImports(
+    actionFile.references,
+    actionFile.depth,
+    options,
+    context
+  );
+  if (contractImports) {
+    if (parts.length > 0) {
+      parts.push("");
+    }
+    parts.push(contractImports);
+  }
+  if (options.reexportChildren) {
+    const extension = context.options.importExtension;
+    const resourceFileName = formatFileName(
+      actionFile.resourceName,
+      context.options.fileCase
+    );
+    for (const child of actionFile.childResources) {
+      const childFileName = formatFileName(child, context.options.fileCase);
+      const childOperationTree = resolveEndpointIdentifier(
+        `${pascalCase(child)}OperationTree`,
+        context
+      );
+      const childConstName = resolveEndpointIdentifier(
+        camelCase(child),
+        context
+      );
+      parts.push("");
+      parts.push(
+        `import type { ${childOperationTree} } from './${resourceFileName}/${childFileName}${extension}';`
+      );
+      parts.push(
+        `import { ${childConstName} } from './${resourceFileName}/${childFileName}${extension}';`
+      );
+    }
+  }
+  if (actionFile.schemaLines.length > 0) {
+    parts.push("");
+    parts.push(actionFile.schemaLines.join("\n\n"));
+  }
+  if (actionFile.typeLines.length > 0) {
+    parts.push("");
+    parts.push(actionFile.typeLines.join("\n\n"));
+  }
+  if (options.endpoints) {
+    parts.push("");
+    const members = [];
+    for (const line of actionFile.endpointLines) {
+      members.push(line);
+    }
+    for (const child of actionFile.childResources) {
+      const childConstName = resolveEndpointIdentifier(
+        camelCase(child),
+        context
+      );
+      members.push(`  ${childConstName},`);
+    }
+    const resourceConstName = resolveEndpointIdentifier(
+      camelCase(actionFile.resourceName),
+      context
+    );
+    parts.push(`export const ${resourceConstName} = {`);
+    parts.push(members.join("\n"));
+    parts.push("} as const;");
+    parts.push("");
+    const interfaceMembers = [];
+    for (const line of actionFile.interfaceLines) {
+      interfaceMembers.push(line);
+    }
+    for (const child of actionFile.childResources) {
+      const childMemberName = camelCase(child);
+      const childOperationTree = resolveEndpointIdentifier(
+        `${pascalCase(child)}OperationTree`,
+        context
+      );
+      interfaceMembers.push(`  ${childMemberName}: ${childOperationTree};`);
+    }
+    const operationTreeName = resolveEndpointIdentifier(
+      `${pascalCase(actionFile.resourceName)}OperationTree`,
+      context
+    );
+    parts.push(`export interface ${operationTreeName} {`);
+    parts.push(interfaceMembers.join("\n"));
+    parts.push("}");
+  }
+  return `${parts.join("\n")}
+`;
+}
+function traverseResources(resources, parentIdentifiers, actionFiles, options, context) {
+  for (const resource of resources) {
+    const schemaLines = [];
+    const typeLines = [];
+    const endpointLines = [];
+    const interfaceLines = [];
+    const references = /* @__PURE__ */ new Set();
+    const childResources = [];
+    for (const action of resource.actions) {
+      generateActionContent(
+        action,
+        parentIdentifiers,
+        resource.identifier,
+        schemaLines,
+        typeLines,
+        endpointLines,
+        interfaceLines,
+        references,
+        options,
+        context
+      );
+    }
+    if (options.reexportChildren) {
+      for (const childResource of resource.resources) {
+        childResources.push(childResource.identifier);
+      }
+    }
+    if (schemaLines.length > 0 || typeLines.length > 0 || childResources.length > 0) {
+      const directoryPath = parentIdentifiers.map(
+        (identifier) => formatFileName(identifier, context.options.fileCase)
+      ).join("/");
+      const fileName = formatFileName(
+        resource.identifier,
+        context.options.fileCase
+      );
+      const filename = directoryPath ? `endpoints/${directoryPath}/${fileName}.ts` : `endpoints/${fileName}.ts`;
+      const depth = filename.split("/").length - 1;
+      actionFiles.push({
+        childResources,
+        depth,
+        endpointLines,
+        filename,
+        interfaceLines,
+        references,
+        resourceName: resource.identifier,
+        schemaLines,
+        typeLines
+      });
+    }
+    if (resource.resources.length > 0) {
+      traverseResources(
+        resource.resources,
+        [...parentIdentifiers, resource.identifier],
+        actionFiles,
+        options,
+        context
+      );
+    }
+  }
+}
+function analyzeAction(action, parentIdentifiers, resourceIdentifier, context) {
+  const segments = action.name.split(".");
+  const actionName = segments[segments.length - 1];
+  const responseBody = action.response.body && !action.response.noContent ? action.response.body : null;
+  const typeName = resolveEndpointIdentifier(
+    pascalCase(
+      [...parentIdentifiers, resourceIdentifier, actionName].join("_")
+    ),
+    context
+  );
+  return {
+    actionName,
+    errorCodes: action.raises.map((code) => resolveErrorStatus(code)).filter((status) => status !== null).sort((a, b) => a - b),
+    method: action.method.toUpperCase(),
+    path: action.path,
+    pathParams: extractPathParams(action.path),
+    requestBody: action.request.body,
+    requestQuery: action.request.query,
+    responseBody,
+    typeName
+  };
+}
+function generateActionContent(action, parentIdentifiers, resourceIdentifier, schemaLines, typeLines, endpointLines, interfaceLines, references, options, context) {
+  const parts = analyzeAction(
+    action,
+    parentIdentifiers,
+    resourceIdentifier,
+    context
+  );
+  generateActionTypes(parts, typeLines, references, context);
+  if (options.zod) {
+    generateActionSchemas(parts, schemaLines, references, context);
+  }
+  if (options.endpoints) {
+    endpointLines.push(generateRuntimeEndpoint(parts));
+    interfaceLines.push(generateOperationMember(parts));
+  }
+}
+function generateActionTypes(parts, lines, references, context) {
+  const { typeName } = parts;
+  lines.push(`export type ${typeName}Method = '${parts.method}';`);
+  lines.push(`export type ${typeName}Path = '${parts.path}';`);
+  if (parts.pathParams.length > 0) {
+    const fields = parts.pathParams.map((param) => `${camelCase(param)}: string`).join("; ");
+    lines.push(`export interface ${typeName}PathParams { ${fields} }`);
+  }
+  if (parts.requestQuery.length > 0) {
+    lines.push(
+      generateRequestQueryType(
+        typeName,
+        parts.requestQuery,
+        references,
+        context
+      )
+    );
+  }
+  if (parts.requestBody.length > 0) {
+    lines.push(
+      generateRequestBodyType(typeName, parts.requestBody, references, context)
+    );
+  }
+  if (parts.responseBody) {
+    lines.push(
+      generateResponseBodyType(
+        typeName,
+        parts.responseBody,
+        references,
+        context
+      )
+    );
+  }
+  if (parts.requestQuery.length > 0 || parts.requestBody.length > 0) {
+    const requestFields = [];
+    if (parts.requestBody.length > 0) {
+      requestFields.push(`body: ${typeName}RequestBody`);
+    }
+    if (parts.requestQuery.length > 0) {
+      requestFields.push(`query: ${typeName}RequestQuery`);
+    }
+    lines.push(
+      `export interface ${typeName}Request { ${requestFields.join("; ")} }`
+    );
+  }
+  if (parts.responseBody) {
+    lines.push(
+      `export interface ${typeName}Response { body: ${typeName}ResponseBody }`
+    );
+  }
+  if (parts.errorCodes.length > 0) {
+    lines.push(
+      `export type ${typeName}Errors = ${parts.errorCodes.join(" | ")};`
+    );
+  }
+  lines.push(generateDefinitionType(parts));
+}
+function generateDefinitionType(parts) {
+  const { typeName } = parts;
+  const fields = [];
+  fields.push(`method: ${typeName}Method`);
+  fields.push(`path: ${typeName}Path`);
+  if (parts.pathParams.length > 0) {
+    fields.push(`pathParams: ${typeName}PathParams`);
+  }
+  if (parts.requestQuery.length > 0 || parts.requestBody.length > 0) {
+    fields.push(`request: ${typeName}Request`);
+  }
+  if (parts.responseBody) {
+    fields.push(`response: ${typeName}Response`);
+  }
+  if (parts.errorCodes.length > 0) {
+    fields.push(`errors: ${typeName}Errors`);
+  }
+  return `export interface ${typeName} { ${fields.join("; ")} }`;
+}
+function generateActionSchemas(parts, lines, references, context) {
+  const { typeName } = parts;
+  if (parts.pathParams.length > 0) {
+    const fields = parts.pathParams.map((param) => `${camelCase(param)}: z.string()`).join(", ");
+    lines.push(
+      `export const ${typeName}PathParamsSchema = z.object({ ${fields} });`
+    );
+  }
+  if (parts.requestQuery.length > 0) {
+    lines.push(
+      generateRequestQuerySchema(
+        typeName,
+        parts.requestQuery,
+        references,
+        context
+      )
+    );
+  }
+  if (parts.requestBody.length > 0) {
+    lines.push(
+      generateRequestBodySchema(
+        typeName,
+        parts.requestBody,
+        references,
+        context
+      )
+    );
+  }
+  if (parts.responseBody) {
+    lines.push(
+      generateResponseBodySchema(
+        typeName,
+        parts.responseBody,
+        references,
+        context
+      )
+    );
+  }
+}
+function generateRuntimeEndpoint(parts) {
+  const { actionName, typeName } = parts;
+  const lines = [];
+  lines.push(`  ${camelCase(actionName)}: {`);
+  lines.push(`    method: '${parts.method}',`);
+  lines.push(`    path: '${parts.path}',`);
+  if (parts.pathParams.length > 0) {
+    lines.push(`    pathParams: ${typeName}PathParamsSchema,`);
+  }
+  if (parts.requestQuery.length > 0 || parts.requestBody.length > 0) {
+    lines.push("    request: {");
+    if (parts.requestQuery.length > 0) {
+      lines.push(`      query: ${typeName}RequestQuerySchema,`);
+    }
+    if (parts.requestBody.length > 0) {
+      lines.push(`      body: ${typeName}RequestBodySchema,`);
+    }
+    lines.push("    },");
+  }
+  if (parts.responseBody) {
+    lines.push("    response: {");
+    lines.push(`      body: ${typeName}ResponseBodySchema,`);
+    lines.push("    },");
+  }
+  if (parts.errorCodes.length > 0) {
+    lines.push(`    errors: [${parts.errorCodes.join(", ")}],`);
+  }
+  lines.push("  },");
+  return lines.join("\n");
+}
+function generateOperationMember(parts) {
+  return `  ${camelCase(parts.actionName)}: Operation<${parts.typeName}>;`;
+}
+function extractPathParams(path) {
+  const matches = path.match(/:(\w+)/g);
+  if (!matches) {
+    return [];
+  }
+  return matches.map((match) => match.slice(1));
+}
+var ERROR_STATUS_MAP = {
+  bad_request: 400,
+  conflict: 409,
+  forbidden: 403,
+  internal_server_error: 500,
+  not_found: 404,
+  unauthorized: 401,
+  unprocessable_entity: 422
+};
+function resolveErrorStatus(code) {
+  return ERROR_STATUS_MAP[code] ?? null;
+}
+function generateRequestQuerySchema(typeName, params, references, context) {
+  const fields = params.sort((a, b) => a.name.localeCompare(b.name)).map((param) => {
+    collectParamReferences(param, references);
+    return `  ${param.name}: ${mapParamToZod(param, context)},`;
+  }).join("\n");
+  return `export const ${typeName}RequestQuerySchema = z.object({
+${fields}
+});`;
+}
+function generateRequestBodySchema(typeName, params, references, context) {
+  const fields = params.sort((a, b) => a.name.localeCompare(b.name)).map((param) => {
+    collectParamReferences(param, references);
+    return `  ${param.name}: ${mapParamToZod(param, context)},`;
+  }).join("\n");
+  return `export const ${typeName}RequestBodySchema = z.object({
+${fields}
+});`;
+}
+function generateResponseBodySchema(typeName, body, references, context) {
+  collectParamReferences(body, references);
+  return `export const ${typeName}ResponseBodySchema = ${mapParamToZod(body, context)};`;
+}
+function generateRequestQueryType(typeName, params, references, context) {
+  const fields = params.sort((a, b) => a.name.localeCompare(b.name)).map((param) => {
+    collectParamReferences(param, references);
+    const optional = isOptionalField(param) ? "?" : "";
+    return `  ${param.name}${optional}: ${mapParamToType(param, context)};`;
+  }).join("\n");
+  return `export interface ${typeName}RequestQuery {
+${fields}
+}`;
+}
+function generateRequestBodyType(typeName, params, references, context) {
+  const fields = params.sort((a, b) => a.name.localeCompare(b.name)).map((param) => {
+    collectParamReferences(param, references);
+    const optional = isOptionalField(param) ? "?" : "";
+    return `  ${param.name}${optional}: ${mapParamToType(param, context)};`;
+  }).join("\n");
+  return `export interface ${typeName}RequestBody {
+${fields}
+}`;
+}
+function generateResponseBodyType(typeName, body, references, context) {
+  collectParamReferences(body, references);
+  return `export type ${typeName}ResponseBody = ${mapParamToType(body, context)};`;
+}
+function buildContractImports(references, depth, options, context) {
+  const importsByFile = /* @__PURE__ */ new Map();
+  const prefix = "../".repeat(depth);
+  const extension = context.options.importExtension;
+  for (const reference of references) {
+    const scope = context.scopeIndex.get(reference);
+    if (scope === void 0) {
+      continue;
+    }
+    const filename = scope === null ? `${prefix}api${extension}` : `${prefix}domains/${formatFileName(scope, context.options.fileCase)}${extension}`;
+    let entry = importsByFile.get(filename);
+    if (!entry) {
+      entry = { schemas: [], types: [] };
+      importsByFile.set(filename, entry);
+    }
+    const name = resolveDomainIdentifier(reference, context);
+    if (options.zod) {
+      entry.schemas.push(`${name}Schema`);
+    }
+    entry.types.push(name);
+  }
+  const lines = [];
+  for (const [filename, entry] of [...importsByFile.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    if (options.zod) {
+      lines.push(
+        `import type { ${entry.types.sort().join(", ")} } from '${filename}';`
+      );
+      lines.push(
+        `import { ${entry.schemas.sort().join(", ")} } from '${filename}';`
+      );
+    } else {
+      lines.push(
+        `import type { ${entry.types.sort().join(", ")} } from '${filename}';`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function buildBarrelExports(actionFiles, files, resolvedOptions) {
+  const directories = /* @__PURE__ */ new Map();
+  for (const actionFile of actionFiles) {
+    const parts = actionFile.filename.split("/");
+    const filename = parts.pop();
+    if (!filename) {
+      throw new Error(`Invalid action file path: ${actionFile.filename}`);
+    }
+    const file = filename.replace(".ts", "");
+    const directory = parts.join("/");
+    let entries = directories.get(directory);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Set();
+      directories.set(directory, entries);
+    }
+    entries.add(file);
+  }
+  for (const directory of [...directories.keys()]) {
+    const parentParts = directory.split("/");
+    if (parentParts.length > 1) {
+      const parentDirectory = parentParts.slice(0, -1).join("/");
+      const childDirectory = parentParts[parentParts.length - 1];
+      let parentEntries = directories.get(parentDirectory);
+      if (!parentEntries) {
+        parentEntries = /* @__PURE__ */ new Set();
+        directories.set(parentDirectory, parentEntries);
+      }
+      parentEntries.add(childDirectory);
+    }
+  }
+  for (const [directory, entries] of directories) {
+    const lines = [...entries].sort().map(
+      (entry) => `export * from './${entry}${resolvedOptions.importExtension}';`
+    );
+    files.set(`${directory}/index.ts`, `${lines.join("\n")}
+`);
+  }
+}
+
+// src/codegen/fs.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+async function writeFiles(outdir, files) {
+  for (const [filename, content] of files) {
+    const filepath = join(outdir, filename);
+    await mkdir(dirname(filepath), { recursive: true });
+    await writeFile(filepath, content);
+  }
+}
+
+// src/typescript/mapper.ts
+function generateEnum(_enum, context) {
+  const name = resolveDomainIdentifier(_enum.name, context);
+  const values = _enum.values.map((value) => `'${value}'`).join(" | ");
+  return `export type ${name} = ${values};`;
+}
+function generateInterface(type, context) {
+  const name = resolveDomainIdentifier(type.name, context);
+  const fields = [...type.shape].sort((a, b) => a.name.localeCompare(b.name)).map((param) => {
+    const optional = isOptionalField(param) ? "?" : "";
+    const typescriptType = mapParamToType(param, context);
+    return `  ${param.name}${optional}: ${typescriptType};`;
+  }).join("\n");
+  if (type.extends.length > 0) {
+    const bases = type.extends.map((base) => resolveDomainIdentifier(base, context)).join(", ");
+    return `export interface ${name} extends ${bases} {
+${fields}
+}`;
+  }
+  return `export interface ${name} {
+${fields}
+}`;
+}
+function generateUnionType(type, context) {
+  const name = resolveDomainIdentifier(type.name, context);
+  if (type.discriminator) {
+    const variants2 = type.variants.map((variant) => {
+      const base = mapParamToType(variant, context);
+      const tag = "tag" in variant ? variant.tag : null;
+      if (tag) {
+        return `${base} & { ${type.discriminator}: '${tag}' }`;
+      }
+      return base;
+    });
+    return `export type ${name} =
+  | ${variants2.join("\n  | ")};`;
+  }
+  const variants = type.variants.map(
+    (variant) => mapParamToType(variant, context)
+  );
+  return `export type ${name} = ${variants.join(" | ")};`;
+}
+function mapParamToType(param, context) {
+  const base = mapBaseType(param, context);
+  return param.nullable ? `${base} | null` : base;
+}
+function mapBaseType(param, context) {
+  switch (param.type) {
+    case "string":
+      return param.enum ? resolveDomainIdentifier(param.enum, context) : "string";
+    case "integer":
+      return param.enum ? resolveDomainIdentifier(param.enum, context) : "number";
+    case "number":
+    case "decimal":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+    case "datetime":
+    case "time":
+      return "string";
+    case "uuid":
+      return "string";
+    case "binary":
+      return "string";
+    case "literal":
+      return typeof param.value === "string" ? `'${param.value}'` : String(param.value);
+    case "array":
+      return param.of ? `${mapParamToType(param.of, context)}[]` : "unknown[]";
+    case "record":
+      return param.of ? `Record<string, ${mapParamToType(param.of, context)}>` : "Record<string, unknown>";
+    case "object":
+      return mapObjectParam(param, context);
+    case "union":
+      return param.variants.map((variant) => mapParamToType(variant, context)).join(" | ");
+    case "reference":
+      return resolveDomainIdentifier(param.reference, context);
+    case "unknown":
+      return "unknown";
+  }
+}
+function mapObjectParam(param, context) {
+  if (param.shape.length === 0) {
+    return "Record<string, unknown>";
+  }
+  const fields = [...param.shape].sort((a, b) => a.name.localeCompare(b.name)).map((field) => {
+    const optional = param.partial || isOptionalField(field) ? "?" : "";
+    return `${field.name}${optional}: ${mapParamToType(field, context)}`;
+  }).join("; ");
+  return `{ ${fields} }`;
+}
+function isOptionalField(param) {
+  return param.optional === true;
+}
+
+// src/codegen/domain.ts
+function buildScopeIndex(schema) {
+  const index = /* @__PURE__ */ new Map();
+  for (const _enum of schema.enums) {
+    index.set(_enum.name, _enum.scope);
+  }
+  for (const type of schema.types) {
+    index.set(type.name, type.scope);
+  }
+  return index;
+}
+function buildSchemas(schema, options, resolvedOptions) {
+  const files = /* @__PURE__ */ new Map();
+  const groups = groupByScope(schema);
+  const scopeIndex = buildScopeIndex(schema);
+  const context = { options: resolvedOptions, scopeIndex };
+  for (const [scope, group] of groups) {
+    const filename = scope === null ? "api.ts" : `domains/${formatFileName(scope, resolvedOptions.fileCase)}.ts`;
+    const content = buildFile(
+      scope,
+      group.enums,
+      group.types,
+      options,
+      context
+    );
+    files.set(filename, content);
+  }
+  const barrelLines = [];
+  for (const scope of [...groups.keys()].filter((scope2) => scope2 !== null).sort()) {
+    barrelLines.push(
+      `export * from './${formatFileName(scope, resolvedOptions.fileCase)}${resolvedOptions.importExtension}';`
+    );
+  }
+  if (barrelLines.length > 0) {
+    files.set("domains/index.ts", `${barrelLines.join("\n")}
+`);
+  }
+  return files;
+}
+function groupByScope(schema) {
+  const groups = /* @__PURE__ */ new Map();
+  function getGroup(scope) {
+    let group = groups.get(scope);
+    if (!group) {
+      group = { enums: [], types: [] };
+      groups.set(scope, group);
+    }
+    return group;
+  }
+  for (const _enum of schema.enums) {
+    getGroup(_enum.scope).enums.push(_enum);
+  }
+  for (const type of schema.types) {
+    getGroup(type.scope).types.push(type);
+  }
+  return groups;
+}
+function buildFile(scope, enums, types, options, context) {
+  const references = collectTypeReferences(types, enums);
+  const imports = buildImports(scope, references, options, context);
+  const lines = [];
+  if (options.zod) {
+    lines.push("import * as z from 'zod';");
+    if (imports) {
+      lines.push("");
+    }
+  }
+  if (imports) {
+    lines.push(imports);
+  }
+  if (lines.length > 0) {
+    lines.push("");
+  }
+  if (options.zod) {
+    for (const _enum of enums) {
+      lines.push(generateEnumSchema(_enum, context));
+      lines.push("");
+    }
+    for (const type of types) {
+      if (type.type === "object") {
+        lines.push(generateObjectSchema(type, context));
+      } else {
+        lines.push(generateUnionSchema(type, context));
+      }
+      lines.push("");
+    }
+  }
+  for (const _enum of enums) {
+    lines.push(generateEnum(_enum, context));
+    lines.push("");
+  }
+  for (const type of types) {
+    if (type.type === "object") {
+      lines.push(generateInterface(type, context));
+    } else {
+      lines.push(generateUnionType(type, context));
+    }
+    lines.push("");
+  }
+  return `${lines.join("\n").trim()}
+`;
+}
+function resolveImportPath(currentScope, targetScope, resolvedOptions) {
+  const extension = resolvedOptions.importExtension;
+  if (currentScope === null) {
+    return `./domains/${formatFileName(targetScope, resolvedOptions.fileCase)}${extension}`;
+  }
+  if (targetScope === null) {
+    return `../api${extension}`;
+  }
+  return `./${formatFileName(targetScope, resolvedOptions.fileCase)}${extension}`;
+}
+function buildImports(currentScope, references, options, context) {
+  const importsByFile = /* @__PURE__ */ new Map();
+  for (const reference of references) {
+    const targetScope = context.scopeIndex.get(reference);
+    if (targetScope === void 0 || targetScope === currentScope) {
+      continue;
+    }
+    const filename = resolveImportPath(
+      currentScope,
+      targetScope,
+      context.options
+    );
+    let entry = importsByFile.get(filename);
+    if (!entry) {
+      entry = { schemas: [], types: [] };
+      importsByFile.set(filename, entry);
+    }
+    const name = resolveDomainIdentifier(reference, context);
+    if (options.zod) {
+      entry.schemas.push(`${name}Schema`);
+    }
+    entry.types.push(name);
+  }
+  const lines = [];
+  for (const [filename, entry] of [...importsByFile.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    if (options.zod) {
+      const allImports = [
+        ...entry.schemas.sort(),
+        ...entry.types.sort().map((name) => `type ${name}`)
+      ];
+      lines.push(`import { ${allImports.join(", ")} } from '${filename}';`);
+    } else {
+      lines.push(
+        `import type { ${entry.types.sort().join(", ")} } from '${filename}';`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  pascalCase,
+  resolveGenerateOptions,
+  resolveDomainIdentifier,
+  resolveEndpointIdentifier,
+  resolveClientIdentifier,
+  buildScopeIndex,
+  buildSchemas,
+  buildEndpoints,
+  writeFiles
+};