@faapi/faapi 0.0.0-canary.0

package/dist/index.js

@@ -0,0 +1,665 @@
+// src/ast/createProgram.ts
+import ts from "typescript";
+var programCache = /* @__PURE__ */ new Map();
+function createProgram(filePath) {
+  const cached = programCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  const program = ts.createProgram([filePath], {
+    strict: true,
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.NodeNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    skipLibCheck: true,
+    noEmit: true
+  });
+  programCache.set(filePath, program);
+  return program;
+}
+
+// src/ast/extractHandlerTypes.ts
+import ts3 from "typescript";
+
+// src/ast/resolveTypeNode.ts
+import ts2 from "typescript";
+var SchemaExtractionError = class extends Error {
+  constructor(typeText, reason, options) {
+    super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
+    this.typeText = typeText;
+    this.reason = reason;
+    this.name = "SchemaExtractionError";
+  }
+  typeText;
+  reason;
+};
+function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  const kind = typeNode.kind;
+  switch (kind) {
+    case ts2.SyntaxKind.StringKeyword:
+      return { kind: "string" };
+    case ts2.SyntaxKind.NumberKeyword:
+      return { kind: "number" };
+    case ts2.SyntaxKind.BooleanKeyword:
+      return { kind: "boolean" };
+    case ts2.SyntaxKind.BigIntKeyword:
+      return { kind: "bigint" };
+    case ts2.SyntaxKind.NullKeyword:
+      return { kind: "null" };
+    case ts2.SyntaxKind.UndefinedKeyword:
+      return { kind: "undefined" };
+    case ts2.SyntaxKind.UnknownKeyword:
+      return { kind: "any" };
+    case ts2.SyntaxKind.AnyKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "any \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528 unknown \u8868\u793A\u4E0D\u6821\u9A8C");
+    case ts2.SyntaxKind.VoidKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "void \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
+    case ts2.SyntaxKind.NeverKeyword:
+      throw new SchemaExtractionError(typeNode.getText(), "never \u4E0D\u652F\u6301\u8FD0\u884C\u65F6\u6821\u9A8C");
+    case ts2.SyntaxKind.ObjectKeyword:
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        "object \u4E0D\u652F\u6301\uFF0C\u8BF7\u4F7F\u7528\u5177\u4F53\u5BF9\u8C61\u7C7B\u578B\u6216 unknown"
+      );
+  }
+  if (ts2.isLiteralTypeNode(typeNode)) {
+    const literal = typeNode.literal;
+    if (ts2.isStringLiteral(literal)) {
+      return { kind: "literal", value: literal.text };
+    }
+    if (ts2.isNumericLiteral(literal)) {
+      return { kind: "literal", value: Number(literal.text) };
+    }
+    if (literal.kind === ts2.SyntaxKind.TrueKeyword) {
+      return { kind: "literal", value: true };
+    }
+    if (literal.kind === ts2.SyntaxKind.FalseKeyword) {
+      return { kind: "literal", value: false };
+    }
+    if (literal.kind === ts2.SyntaxKind.NullKeyword) {
+      return { kind: "null" };
+    }
+    throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u5B57\u9762\u91CF\u7C7B\u578B");
+  }
+  if (ts2.isArrayTypeNode(typeNode)) {
+    return {
+      kind: "array",
+      element: resolveTypeNode(typeNode.elementType, checker, visited)
+    };
+  }
+  if (ts2.isTupleTypeNode(typeNode)) {
+    const elements = typeNode.elements.map((e) => resolveTypeNode(e, checker, visited));
+    return { kind: "array", element: { kind: "union", members: elements } };
+  }
+  if (ts2.isUnionTypeNode(typeNode)) {
+    const members = typeNode.types.map((t) => resolveTypeNode(t, checker, visited));
+    return { kind: "union", members };
+  }
+  if (ts2.isIntersectionTypeNode(typeNode)) {
+    const properties = [];
+    for (const t of typeNode.types) {
+      const resolved = resolveTypeNode(t, checker, visited);
+      if (resolved.kind === "object") {
+        properties.push(...resolved.properties);
+      }
+    }
+    return { kind: "object", properties };
+  }
+  if (ts2.isTypeLiteralNode(typeNode)) {
+    return resolveTypeLiteral(typeNode, checker, visited);
+  }
+  if (ts2.isTypeOperatorNode(typeNode) && typeNode.operator === ts2.SyntaxKind.KeyOfKeyword) {
+    return resolveKeyOf(typeNode, checker);
+  }
+  if (ts2.isTypeReferenceNode(typeNode)) {
+    return resolveTypeReference(typeNode, checker, visited);
+  }
+  throw new SchemaExtractionError(typeNode.getText(), "\u4E0D\u652F\u6301\u7684\u7C7B\u578B\u8BED\u6CD5");
+}
+function resolveTypeLiteral(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  const properties = [];
+  for (const member of typeNode.members) {
+    if (ts2.isPropertySignature(member) && member.name) {
+      const name = member.name.getText();
+      const optional = !!member.questionToken;
+      const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      properties.push({ name, type, optional });
+    }
+    if (ts2.isIndexSignatureDeclaration(member)) {
+      const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
+      const valueType = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      return { kind: "record", key: keyType, value: valueType };
+    }
+  }
+  return { kind: "object", properties };
+}
+function extractLiteralKeys(type) {
+  if (type.kind === "literal" && typeof type.value === "string") {
+    return [type.value];
+  }
+  if (type.kind === "union") {
+    const keys = [];
+    for (const member of type.members) {
+      if (member.kind === "literal" && typeof member.value === "string") {
+        keys.push(member.value);
+      } else {
+        return null;
+      }
+    }
+    return keys;
+  }
+  return null;
+}
+function extractKeysFromChecker(typeNode, checker) {
+  if (!checker) return null;
+  const type = checker.getTypeFromTypeNode(typeNode);
+  if (type.isUnion()) {
+    const keys = [];
+    for (const member of type.types) {
+      if (member.isStringLiteral()) {
+        keys.push(member.value);
+      } else if (member.isNumberLiteral()) {
+        keys.push(String(member.value));
+      } else {
+        return null;
+      }
+    }
+    return keys;
+  }
+  if (type.isStringLiteral()) {
+    return [type.value];
+  }
+  if (type.isNumberLiteral()) {
+    return [String(type.value)];
+  }
+  return null;
+}
+function resolveKeyOf(typeNode, checker) {
+  if (!checker) {
+    throw new SchemaExtractionError(typeNode.getText(), "keyof T \u9700\u8981 checker \u624D\u80FD\u89E3\u6790");
+  }
+  const type = checker.getTypeFromTypeNode(typeNode);
+  if (type.isUnion()) {
+    const members = [];
+    for (const member of type.types) {
+      if (member.isStringLiteral()) {
+        members.push({ kind: "literal", value: member.value });
+      } else if (member.isNumberLiteral()) {
+        members.push({ kind: "literal", value: member.value });
+      } else {
+        throw new SchemaExtractionError(typeNode.getText(), "keyof T \u7684\u7ED3\u679C\u5305\u542B\u975E\u5B57\u9762\u91CF\u7C7B\u578B");
+      }
+    }
+    return { kind: "union", members };
+  }
+  if (type.isStringLiteral()) {
+    return { kind: "literal", value: type.value };
+  }
+  if (type.isNumberLiteral()) {
+    return { kind: "literal", value: type.value };
+  }
+  throw new SchemaExtractionError(typeNode.getText(), "keyof T \u7684\u7ED3\u679C\u65E0\u6CD5\u89E3\u6790\u4E3A\u5B57\u9762\u91CF\u8054\u5408");
+}
+function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  const typeName = typeNode.typeName.getText();
+  if (typeName === "Date") {
+    return { kind: "date" };
+  }
+  if (typeName === "Array" && typeNode.typeArguments?.length === 1) {
+    return {
+      kind: "array",
+      element: resolveTypeNode(typeNode.typeArguments[0], checker, visited)
+    };
+  }
+  if (typeName === "Record" && typeNode.typeArguments?.length === 2) {
+    return {
+      kind: "record",
+      key: resolveTypeNode(typeNode.typeArguments[0], checker, visited),
+      value: resolveTypeNode(typeNode.typeArguments[1], checker, visited)
+    };
+  }
+  if ((typeName === "Partial" || typeName === "Required" || typeName === "Readonly") && typeNode.typeArguments?.length === 1) {
+    const inner = resolveTypeNode(typeNode.typeArguments[0], checker, visited);
+    if (inner.kind === "object" && typeName === "Partial") {
+      return {
+        kind: "object",
+        properties: inner.properties.map((p) => ({ ...p, optional: true }))
+      };
+    }
+    return inner;
+  }
+  if ((typeName === "Pick" || typeName === "Omit") && typeNode.typeArguments?.length === 2) {
+    const innerType = resolveTypeNode(typeNode.typeArguments[0], checker, visited);
+    if (innerType.kind !== "object") {
+      throw new SchemaExtractionError(
+        typeNode.getText(),
+        `${typeName} \u7684 T \u5FC5\u987B\u662F\u5BF9\u8C61\u7C7B\u578B\uFF0C\u5B9E\u9645\u4E3A ${innerType.kind}`
+      );
+    }
+    const keyTypeNode = typeNode.typeArguments[1];
+    let keys = extractLiteralKeys(resolveTypeNode(keyTypeNode, checker, visited));
+    if (keys === null) {
+      keys = extractKeysFromChecker(keyTypeNode, checker);
+    }
+    if (keys === null) {
+      throw new SchemaExtractionError(typeNode.getText(), `${typeName} \u7684 K \u65E0\u6CD5\u89E3\u6790\u4E3A\u5B57\u9762\u91CF\u96C6\u5408`);
+    }
+    const keySet = new Set(keys);
+    const properties = typeName === "Pick" ? innerType.properties.filter((p) => keySet.has(p.name)) : innerType.properties.filter((p) => !keySet.has(p.name));
+    return { kind: "object", properties };
+  }
+  if (typeName === "Map" || typeName === "Set" || typeName === "WeakMap" || typeName === "WeakSet") {
+    throw new SchemaExtractionError(
+      typeNode.getText(),
+      `${typeName} \u8FD0\u884C\u65F6\u65E0\u6CD5\u6821\u9A8C\uFF0C\u8BF7\u6539\u7528\u5BF9\u8C61\u6216\u6570\u7EC4`
+    );
+  }
+  if (typeName === "Promise") {
+    throw new SchemaExtractionError(
+      typeNode.getText(),
+      "Promise \u8FD0\u884C\u65F6\u65E0\u6CD5\u6821\u9A8C\uFF0C\u8BF7\u52FF\u5728 query/body \u7C7B\u578B\u4E2D\u4F7F\u7528"
+    );
+  }
+  if (visited.has(typeName)) {
+    return { kind: "ref", name: typeName };
+  }
+  visited.add(typeName);
+  if (checker) {
+    const symbol = typeNode.typeName.kind === ts2.SyntaxKind.Identifier ? checker.getSymbolAtLocation(typeNode.typeName) : void 0;
+    if (symbol) {
+      const declaration = symbol.declarations?.[0];
+      if (declaration) {
+        if (ts2.isInterfaceDeclaration(declaration)) {
+          return resolveInterfaceDeclaration(declaration, checker, visited);
+        }
+        if (ts2.isTypeAliasDeclaration(declaration)) {
+          return resolveTypeNode(declaration.type, checker, visited);
+        }
+      }
+    }
+  }
+  throw new SchemaExtractionError(typeNode.getText(), `\u65E0\u6CD5\u89E3\u6790\u7684\u5F15\u7528\u7C7B\u578B "${typeName}"`);
+}
+function resolveInterfaceDeclaration(node, checker, visited = /* @__PURE__ */ new Set()) {
+  const properties = [];
+  const propMap = /* @__PURE__ */ new Map();
+  for (const heritageClause of node.heritageClauses ?? []) {
+    if (heritageClause.token === ts2.SyntaxKind.ExtendsKeyword) {
+      for (const expr of heritageClause.types) {
+        const parentType = resolveTypeNode(expr, checker, visited);
+        if (parentType.kind === "object") {
+          for (const prop of parentType.properties) {
+            propMap.set(prop.name, prop);
+          }
+        }
+      }
+    }
+  }
+  for (const member of node.members) {
+    if (ts2.isPropertySignature(member) && member.name) {
+      const name = member.name.getText();
+      const optional = !!member.questionToken;
+      const type = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      propMap.set(name, { name, type, optional });
+    }
+    if (ts2.isIndexSignatureDeclaration(member)) {
+      const keyType = member.parameters[0]?.type ? resolveTypeNode(member.parameters[0].type, checker, visited) : { kind: "any" };
+      const valueType = member.type ? resolveTypeNode(member.type, checker, visited) : { kind: "any" };
+      return { kind: "record", key: keyType, value: valueType };
+    }
+  }
+  for (const prop of propMap.values()) {
+    properties.push(prop);
+  }
+  return { kind: "object", properties };
+}
+
+// src/ast/extractHandlerTypes.ts
+function extractTypeInfo(program, filePath, typeName) {
+  const sourceFile = program.getSourceFile(filePath);
+  if (!sourceFile) return null;
+  const checker = program.getTypeChecker();
+  let result = null;
+  ts3.forEachChild(sourceFile, (node) => {
+    if (result) return;
+    if (ts3.isInterfaceDeclaration(node) && node.name.text === typeName) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(typeName);
+      const runtimeType = withFileContext(
+        filePath,
+        typeName,
+        () => resolveInterfaceDeclaration(node, checker, visited)
+      );
+      result = {
+        name: typeName,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      };
+      return;
+    }
+    if (ts3.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+      const visited = /* @__PURE__ */ new Set();
+      visited.add(typeName);
+      const runtimeType = withFileContext(
+        filePath,
+        typeName,
+        () => resolveTypeNode(node.type, checker, visited)
+      );
+      result = {
+        name: typeName,
+        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+        runtimeType
+      };
+      return;
+    }
+  });
+  return result;
+}
+function withFileContext(filePath, typeName, fn) {
+  try {
+    return fn();
+  } catch (err) {
+    if (err instanceof SchemaExtractionError) {
+      const fileName = filePath.split("/").pop() ?? filePath;
+      const enriched = new SchemaExtractionError(
+        err.typeText,
+        `${err.reason}\uFF08\u6587\u4EF6: ${fileName}, \u7C7B\u578B: ${typeName}\uFF09`,
+        { cause: err }
+      );
+      throw enriched;
+    }
+    throw err;
+  }
+}
+
+// src/runtime/inputType.ts
+function getInputTypeForMethod(method) {
+  const upper = method.toUpperCase();
+  if (upper === "GET" || upper === "DELETE" || upper === "HEAD") {
+    return "query";
+  }
+  return "body";
+}
+
+// src/validator/schemaRegistry.ts
+var SchemaRegistry = class {
+  manifest = /* @__PURE__ */ new Map();
+  /**
+   * 批量加载 manifest
+   * 覆盖已有数据
+   */
+  loadManifest(manifest) {
+    this.manifest.clear();
+    for (const [filePath, fileSchemas] of manifest) {
+      const copy = /* @__PURE__ */ new Map();
+      fileSchemas.forEach((value, key) => copy.set(key, value));
+      this.manifest.set(filePath, copy);
+    }
+  }
+  /**
+   * 查询单条 schema
+   * @returns SchemaEntry | null | undefined
+   *          - SchemaEntry：有类型声明
+   *          - null：无类型声明（跳过校验）
+   *          - undefined：manifest 不完整（抛错）
+   */
+  get(filePath, schemaName) {
+    const fileSchemas = this.manifest.get(filePath);
+    if (!fileSchemas) return void 0;
+    return fileSchemas.get(schemaName);
+  }
+  /**
+   * 设置单个文件的所有 schema
+   * 覆盖该文件的已有数据
+   */
+  set(filePath, schemas) {
+    const copy = /* @__PURE__ */ new Map();
+    schemas.forEach((value, key) => copy.set(key, value));
+    this.manifest.set(filePath, copy);
+  }
+  /**
+   * 删除单个文件（文件被删除时）
+   */
+  delete(filePath) {
+    this.manifest.delete(filePath);
+  }
+  /**
+   * 判断文件是否已注册
+   */
+  hasFile(filePath) {
+    return this.manifest.has(filePath);
+  }
+  /**
+   * 清空（测试用 / watch 全量重建前）
+   */
+  clear() {
+    this.manifest.clear();
+  }
+  /**
+   * 已注册的文件数量
+   */
+  get size() {
+    return this.manifest.size;
+  }
+};
+var schemaRegistry = new SchemaRegistry();
+
+// src/validator/schemaName.ts
+function getSchemaName(method, inputType) {
+  return `${method.toUpperCase()}${inputType.charAt(0).toUpperCase() + inputType.slice(1)}`;
+}
+
+// src/validator/getSchemaProperties.ts
+function getSchemaProperties(filePath, method, inputType) {
+  const schemaName = getSchemaName(method, inputType);
+  const entry = schemaRegistry.get(filePath, schemaName);
+  if (entry === void 0) return void 0;
+  if (entry === null) {
+    return { schemaName: null, properties: [] };
+  }
+  return {
+    schemaName,
+    properties: entry.properties.map((prop) => ({
+      name: prop.name,
+      type: runtimeTypeToString(prop.type),
+      required: !prop.optional
+    }))
+  };
+}
+function runtimeTypeToString(type) {
+  switch (type.kind) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "null":
+    case "undefined":
+    case "date":
+      return type.kind;
+    case "literal":
+      return JSON.stringify(type.value);
+    case "array":
+      return `${runtimeTypeToString(type.element)}[]`;
+    case "object":
+      return "object";
+    case "union":
+      return type.members.map(runtimeTypeToString).join(" | ");
+    case "record":
+      return `Record<${runtimeTypeToString(type.key)}, ${runtimeTypeToString(type.value)}>`;
+    case "ref":
+      return type.name;
+    case "any":
+    case "unknown":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+
+// src/middleware/cors.ts
+var DEFAULT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function cors(options = {}) {
+  const {
+    origin = true,
+    methods = DEFAULT_METHODS,
+    allowedHeaders,
+    exposeHeaders,
+    credentials = false,
+    maxAge
+  } = options;
+  return async (ctx, next) => {
+    const reqOrigin = ctx.headers.get("origin");
+    if (!reqOrigin) {
+      await next();
+      return;
+    }
+    let allowOrigin = null;
+    if (origin === true) {
+      allowOrigin = reqOrigin;
+    } else if (typeof origin === "string") {
+      allowOrigin = reqOrigin === origin ? origin : null;
+    } else if (Array.isArray(origin)) {
+      allowOrigin = origin.includes(reqOrigin) ? reqOrigin : null;
+    }
+    if (!allowOrigin) {
+      await next();
+      return;
+    }
+    ctx.setHeader("Access-Control-Allow-Origin", allowOrigin);
+    if (origin === true || Array.isArray(origin)) {
+      const existingVary = ctx.headers.get("vary");
+      if (existingVary) {
+        if (!existingVary.toLowerCase().includes("origin")) {
+          ctx.setHeader("Vary", `${existingVary}, Origin`);
+        }
+      } else {
+        ctx.setHeader("Vary", "Origin");
+      }
+    }
+    ctx.setHeader("Access-Control-Allow-Methods", methods.join(", "));
+    if (allowedHeaders) {
+      ctx.setHeader("Access-Control-Allow-Headers", allowedHeaders.join(", "));
+    } else {
+      const requestHeaders = ctx.headers.get("access-control-request-headers");
+      if (requestHeaders) {
+        ctx.setHeader("Access-Control-Allow-Headers", requestHeaders);
+      }
+    }
+    if (exposeHeaders && exposeHeaders.length > 0) {
+      ctx.setHeader("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+    }
+    if (credentials) {
+      ctx.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+    if (maxAge !== void 0) {
+      ctx.setHeader("Access-Control-Max-Age", String(maxAge));
+    }
+    if (ctx.method === "OPTIONS") {
+      return new Response(null, { status: 204 });
+    }
+    await next();
+  };
+}
+
+// src/middleware/logger.ts
+function logger(options = {}) {
+  const { log = console.log } = options;
+  return async (ctx, next) => {
+    const start = Date.now();
+    try {
+      const response = await next();
+      const duration = Date.now() - start;
+      log(`${ctx.method} ${ctx.path} ${response.status} ${duration}ms`);
+      return response;
+    } catch (err) {
+      const duration = Date.now() - start;
+      const message = err instanceof Error ? err.message : String(err);
+      const status = err?.statusCode ?? 500;
+      log(`${ctx.method} ${ctx.path} ${status} ${duration}ms - ${message}`);
+      throw err;
+    }
+  };
+}
+
+// src/config/loadConfig.ts
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+var BASE_CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
+function getEnv() {
+  return process.env.NODE_ENV || process.env.FAAPI_ENV || "development";
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overVal = override[key];
+    if (baseVal instanceof Date || overVal instanceof Date || baseVal instanceof RegExp || overVal instanceof RegExp || baseVal instanceof Map || overVal instanceof Map || baseVal instanceof Set || overVal instanceof Set) {
+      result[key] = overVal;
+      continue;
+    }
+    if (baseVal !== null && overVal !== null && typeof baseVal === "object" && typeof overVal === "object" && !Array.isArray(baseVal) && !Array.isArray(overVal) && !(baseVal instanceof Function) && !(overVal instanceof Function)) {
+      result[key] = deepMerge(
+        baseVal,
+        overVal
+      );
+    } else {
+      result[key] = overVal;
+    }
+  }
+  return result;
+}
+async function loadConfigFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const url = pathToFileURL(filePath).href;
+    const module = await import(url);
+    return module.default ?? {};
+  } catch (err) {
+    throw new Error(
+      `Failed to load config file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+}
+async function loadConfig(rootDir, configPath) {
+  if (configPath) {
+    const resolvedPath = path.resolve(rootDir, configPath);
+    if (!fs.existsSync(resolvedPath)) {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+    return loadConfigFile(resolvedPath);
+  }
+  let baseConfig = null;
+  for (const fileName of BASE_CONFIG_FILES) {
+    const filePath = path.join(rootDir, fileName);
+    baseConfig = await loadConfigFile(filePath);
+    if (baseConfig) break;
+  }
+  if (!baseConfig) {
+    return null;
+  }
+  const env = getEnv();
+  const envFiles = [`faapi.config.${env}.ts`, `faapi.config.${env}.js`];
+  for (const envFile of envFiles) {
+    const envConfig = await loadConfigFile(path.join(rootDir, envFile));
+    if (envConfig) {
+      baseConfig = deepMerge(baseConfig, envConfig);
+      break;
+    }
+  }
+  return baseConfig;
+}
+export {
+  SchemaExtractionError,
+  cors,
+  createProgram,
+  extractTypeInfo,
+  getInputTypeForMethod,
+  getSchemaProperties,
+  loadConfig,
+  logger
+};
+//# sourceMappingURL=index.js.map