@sdk-it/core 0.19.0 → 0.20.0

package/dist/index.js

@@ -1,920 +1,12 @@
-// packages/core/src/index.ts
 import {
   pascalcase as _pascalcase,
   snakecase as _snakecase,
   spinalcase as _spinalcase
 } from "stringcase";
-
-// packages/core/src/lib/deriver.ts
-import ts, { TypeFlags, symbolName } from "typescript";
-var deriveSymbol = Symbol.for("serialize");
-var $types = Symbol.for("types");
-var defaults = {
-  Readable: "any",
-  ReadableStream: "any",
-  DateConstructor: "string",
-  ArrayBufferConstructor: "any",
-  SharedArrayBufferConstructor: "any",
-  Int8ArrayConstructor: "any",
-  Uint8Array: "any"
-};
-var TypeDeriver = class {
-  collector = {};
-  checker;
-  constructor(checker) {
-    this.checker = checker;
-  }
-  serializeType(type) {
-    const indexType = type.getStringIndexType();
-    if (indexType) {
-      return {
-        [deriveSymbol]: true,
-        kind: "record",
-        optional: false,
-        [$types]: [this.serializeType(indexType)]
-      };
-    }
-    if (type.flags & TypeFlags.Any) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: []
-      };
-    }
-    if (type.flags & TypeFlags.Unknown) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: []
-      };
-    }
-    if (type.isStringLiteral()) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        kind: "literal",
-        value: type.value,
-        [$types]: ["string"]
-      };
-    }
-    if (type.isNumberLiteral()) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        kind: "literal",
-        value: type.value,
-        [$types]: ["number"]
-      };
-    }
-    if (type.flags & TypeFlags.BooleanLiteral) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: ["boolean"]
-      };
-    }
-    if (type.flags & TypeFlags.TemplateLiteral) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: ["string"]
-      };
-    }
-    if (type.flags & TypeFlags.String) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: ["string"]
-      };
-    }
-    if (type.flags & TypeFlags.Number) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: ["number"]
-      };
-    }
-    if (type.flags & ts.TypeFlags.Boolean) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: ["boolean"]
-      };
-    }
-    if (type.flags & TypeFlags.Null) {
-      return {
-        [deriveSymbol]: true,
-        optional: true,
-        [$types]: ["null"]
-      };
-    }
-    if (type.isIntersection()) {
-      let optional;
-      const types = [];
-      for (const unionType of type.types) {
-        if (optional === void 0) {
-          optional = (unionType.flags & ts.TypeFlags.Undefined) !== 0;
-          if (optional) {
-            continue;
-          }
-        }
-        types.push(this.serializeType(unionType));
-      }
-      return {
-        [deriveSymbol]: true,
-        kind: "intersection",
-        optional,
-        [$types]: types
-      };
-    }
-    if (type.isUnion()) {
-      let optional;
-      const types = [];
-      for (const unionType of type.types) {
-        if (optional === void 0) {
-          optional = (unionType.flags & ts.TypeFlags.Undefined) !== 0;
-          if (optional) {
-            continue;
-          }
-        }
-        types.push(this.serializeType(unionType));
-      }
-      return {
-        [deriveSymbol]: true,
-        kind: "union",
-        optional,
-        [$types]: types
-      };
-    }
-    if (this.checker.isArrayLikeType(type)) {
-      const [argType] = this.checker.getTypeArguments(type);
-      if (!argType) {
-        const typeName = type.symbol?.getName() || "<unknown>";
-        console.warn(
-          `Could not find generic type argument for array type ${typeName}`
-        );
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          kind: "array",
-          [$types]: ["any"]
-        };
-      }
-      const typeSymbol = argType.getSymbol();
-      if (!typeSymbol) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          kind: "array",
-          [$types]: [this.serializeType(argType)]
-        };
-      }
-      if (typeSymbol.valueDeclaration) {
-        return {
-          kind: "array",
-          [deriveSymbol]: true,
-          [$types]: [this.serializeNode(typeSymbol.valueDeclaration)]
-        };
-      }
-      const maybeDeclaration = typeSymbol.declarations?.[0];
-      if (maybeDeclaration) {
-        if (ts.isMappedTypeNode(maybeDeclaration)) {
-          const resolvedType = this.checker.getPropertiesOfType(argType).reduce((acc, prop) => {
-            const propType = this.checker.getTypeOfSymbol(prop);
-            acc[prop.name] = this.serializeType(propType);
-            return acc;
-          }, {});
-          return {
-            kind: "array",
-            optional: false,
-            [deriveSymbol]: true,
-            [$types]: [resolvedType]
-          };
-        } else {
-          return {
-            kind: "array",
-            ...this.serializeNode(maybeDeclaration)
-          };
-        }
-      }
-      return {
-        kind: "array",
-        optional: false,
-        [deriveSymbol]: true,
-        [$types]: ["any"]
-      };
-    }
-    if (type.isClass()) {
-      const declaration = type.symbol?.valueDeclaration;
-      if (!declaration) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          [$types]: [type.symbol.getName()]
-        };
-      }
-      return this.serializeNode(declaration);
-    }
-    if (isInterfaceType(type)) {
-      const valueDeclaration = type.symbol.valueDeclaration ?? type.symbol.declarations?.[0];
-      if (!valueDeclaration) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          [$types]: [type.symbol.getName()]
-        };
-      }
-      return this.serializeNode(valueDeclaration);
-    }
-    if (type.flags & TypeFlags.Object) {
-      if (defaults[symbolName(type.symbol)]) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          [$types]: [defaults[type.symbol.name]]
-        };
-      }
-      const properties = this.checker.getPropertiesOfType(type);
-      if (properties.length > 0) {
-        const serializedProps = {};
-        for (const prop of properties) {
-          const propAssingment = (prop.getDeclarations() ?? []).find(
-            (it) => ts.isPropertyAssignment(it)
-          );
-          if (propAssingment) {
-            const type2 = this.checker.getTypeAtLocation(
-              propAssingment.initializer
-            );
-            serializedProps[prop.name] = this.serializeType(type2);
-          }
-          if ((prop.getDeclarations() ?? []).find(
-            (it) => ts.isPropertySignature(it)
-          )) {
-            const propType = this.checker.getTypeOfSymbol(prop);
-            serializedProps[prop.name] = this.serializeType(propType);
-          }
-        }
-        return {
-          [deriveSymbol]: true,
-          kind: "object",
-          optional: false,
-          [$types]: [serializedProps]
-        };
-      }
-      const declaration = type.symbol.valueDeclaration ?? type.symbol.declarations?.[0];
-      if (!declaration) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          [$types]: [type.symbol.getName()]
-        };
-      }
-      return this.serializeNode(declaration);
-    }
-    console.warn(`Unhandled type: ${type.flags} ${ts.TypeFlags[type.flags]}`);
-    return {
-      [deriveSymbol]: true,
-      optional: false,
-      [$types]: [
-        this.checker.typeToString(
-          type,
-          void 0,
-          ts.TypeFormatFlags.NoTruncation
-        )
-      ]
-    };
-  }
-  serializeNode(node) {
-    if (ts.isObjectLiteralExpression(node)) {
-      const symbolType = this.checker.getTypeAtLocation(node);
-      const props = {};
-      for (const symbol of symbolType.getProperties()) {
-        const type = this.checker.getTypeOfSymbol(symbol);
-        props[symbol.name] = this.serializeType(type);
-      }
-      for (const prop of node.properties) {
-        if (ts.isPropertyAssignment(prop)) {
-          const type = this.checker.getTypeAtLocation(prop.initializer);
-          props[prop.name.getText()] = this.serializeType(type);
-        }
-      }
-      return props;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node.name);
-      if (!symbol) {
-        console.warn(`No symbol found for ${node.name.getText()}`);
-        return null;
-      }
-      const type = this.checker.getTypeOfSymbol(symbol);
-      return this.serializeType(type);
-    }
-    if (ts.isPropertySignature(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node.name);
-      if (!symbol) {
-        console.warn(`No symbol found for ${node.name.getText()}`);
-        return null;
-      }
-      const type = this.checker.getTypeOfSymbol(symbol);
-      return this.serializeType(type);
-    }
-    if (ts.isPropertyDeclaration(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node.name);
-      if (!symbol) {
-        console.warn(`No symbol found for ${node.name.getText()}`);
-        return null;
-      }
-      const type = this.checker.getTypeOfSymbol(symbol);
-      return this.serializeType(type);
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      if (!node.name?.text) {
-        throw new Error("Interface has no name");
-      }
-      if (defaults[node.name.text]) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          [$types]: [defaults[node.name.text]]
-        };
-      }
-      if (!this.collector[node.name.text]) {
-        this.collector[node.name.text] = {};
-        const members = {};
-        for (const member of node.members.filter(ts.isPropertySignature)) {
-          members[member.name.getText()] = this.serializeNode(member);
-        }
-        this.collector[node.name.text] = members;
-      }
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: [`#/components/schemas/${node.name.text}`]
-      };
-    }
-    if (ts.isClassDeclaration(node)) {
-      if (!node.name?.text) {
-        throw new Error("Class has no name");
-      }
-      if (defaults[node.name.text]) {
-        return {
-          [deriveSymbol]: true,
-          optional: false,
-          [$types]: [defaults[node.name.text]]
-        };
-      }
-      if (!this.collector[node.name.text]) {
-        this.collector[node.name.text] = {};
-        const members = {};
-        for (const member of node.members.filter(ts.isPropertyDeclaration)) {
-          members[member.name.getText()] = this.serializeNode(member);
-        }
-        this.collector[node.name.text] = members;
-      }
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: [`#/components/schemas/${node.name.text}`],
-        $ref: `#/components/schemas/${node.name.text}`
-      };
-    }
-    if (ts.isVariableDeclaration(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node.name);
-      if (!symbol) {
-        console.warn(`No symbol found for ${node.name.getText()}`);
-        return null;
-      }
-      if (!node.type) {
-        console.warn(`No type found for ${node.name.getText()}`);
-        return "any";
-      }
-      const type = this.checker.getTypeFromTypeNode(node.type);
-      return this.serializeType(type);
-    }
-    if (ts.isIdentifier(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node);
-      if (!symbol) {
-        console.warn(`Identifer: No symbol found for ${node.getText()}`);
-        return null;
-      }
-      const type = this.checker.getTypeAtLocation(node);
-      return this.serializeType(type);
-    }
-    if (ts.isAwaitExpression(node)) {
-      const type = this.checker.getTypeAtLocation(node);
-      return this.serializeType(type);
-    }
-    if (ts.isCallExpression(node)) {
-      const type = this.checker.getTypeAtLocation(node);
-      return this.serializeType(type);
-    }
-    if (ts.isAsExpression(node)) {
-      const type = this.checker.getTypeAtLocation(node);
-      return this.serializeType(type);
-    }
-    if (ts.isTypeLiteralNode(node)) {
-      const symbolType = this.checker.getTypeAtLocation(node);
-      const props = {};
-      for (const symbol of symbolType.getProperties()) {
-        const type = this.checker.getTypeOfSymbol(symbol);
-        props[symbol.name] = this.serializeType(type);
-      }
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: [props]
-      };
-    }
-    if (node.kind === ts.SyntaxKind.NullKeyword) {
-      return {
-        [deriveSymbol]: true,
-        optional: true,
-        [$types]: ["null"]
-      };
-    }
-    if (node.kind === ts.SyntaxKind.BooleanKeyword) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        [$types]: ["boolean"]
-      };
-    }
-    if (node.kind === ts.SyntaxKind.TrueKeyword) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        kind: "literal",
-        value: true,
-        [$types]: ["boolean"]
-      };
-    }
-    if (node.kind === ts.SyntaxKind.FalseKeyword) {
-      return {
-        [deriveSymbol]: true,
-        optional: false,
-        kind: "literal",
-        value: false,
-        [$types]: ["boolean"]
-      };
-    }
-    if (ts.isArrayLiteralExpression(node)) {
-      const type = this.checker.getTypeAtLocation(node);
-      return this.serializeType(type);
-    }
-    console.warn(`Unhandled node: ${ts.SyntaxKind[node.kind]} ${node.flags}`);
-    return {
-      [deriveSymbol]: true,
-      optional: false,
-      [$types]: ["any"]
-    };
-  }
-};
-function isInterfaceType(type) {
-  if (type.isClassOrInterface()) {
-    return !!(type.symbol.flags & ts.SymbolFlags.Interface);
-  }
-  return false;
-}
-
-// packages/core/src/lib/file-system.ts
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, join } from "node:path";
-async function getFile(filePath) {
-  if (await exist(filePath)) {
-    return readFile(filePath, "utf-8");
-  }
-  return null;
-}
-async function exist(file) {
-  return stat(file).then(() => true).catch(() => false);
-}
-async function readFolder(path) {
-  if (await exist(path)) {
-    return readdir(path);
-  }
-  return [];
-}
-async function writeFiles(dir, contents) {
-  await Promise.all(
-    Object.entries(contents).map(async ([file, content]) => {
-      if (content === null) {
-        return;
-      }
-      const filePath = isAbsolute(file) ? file : join(dir, file);
-      await mkdir(dirname(filePath), { recursive: true });
-      if (typeof content === "string") {
-        await writeFile(filePath, content, "utf-8");
-      } else {
-        if (content.ignoreIfExists) {
-          if (!await exist(filePath)) {
-            await writeFile(filePath, content.content, "utf-8");
-          }
-        } else {
-          await writeFile(filePath, content.content, "utf-8");
-        }
-      }
-    })
-  );
-}
-async function getFolderExports(folder, includeExtension = true, extensions = ["ts"], ignore = () => false) {
-  const files = await readdir(folder, { withFileTypes: true });
-  const exports = [];
-  for (const file of files) {
-    if (ignore(file)) {
-      continue;
-    }
-    if (file.isDirectory()) {
-      if (await exist(`${file.parentPath}/${file.name}/index.ts`)) {
-        exports.push(
-          `export * from './${file.name}/index${includeExtension ? ".ts" : ""}';`
-        );
-      }
-    } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
-      exports.push(
-        `export * from './${includeExtension ? file.name : file.name.replace(extname(file.name), "")}';`
-      );
-    }
-  }
-  return exports.join("\n");
-}
-async function getFolderExportsV2(folder, options = {
-  extensions: "ts",
-  ignore: () => false,
-  includeExtension: true,
-  exportSyntax: "export * from "
-}) {
-  options.includeExtension ??= true;
-  if (!await exist(folder)) {
-    return "";
-  }
-  const files = await readdir(folder, { withFileTypes: true });
-  const exports = [];
-  for (const file of files) {
-    if (options.ignore?.(file)) {
-      continue;
-    }
-    if (file.isDirectory()) {
-      if (await exist(
-        `${file.parentPath}/${file.name}/index.${options.extensions}`
-      )) {
-        exports.push(
-          `${options.exportSyntax} './${file.name}/index${options.includeExtension ? `.${options.extensions}` : ""}';`
-        );
-      }
-    } else if (file.name !== `index.${options.extensions}` && options.extensions.includes(getExt(file.name))) {
-      exports.push(
-        `${options.exportSyntax} './${options.includeExtension ? file.name : file.name.replace(extname(file.name), "")}';`
-      );
-    }
-  }
-  return exports.join("\n");
-}
-var getExt = (fileName) => {
-  if (!fileName) {
-    return "";
-  }
-  const lastDot = fileName.lastIndexOf(".");
-  if (lastDot === -1) {
-    return "";
-  }
-  const ext = fileName.slice(lastDot + 1).split("/").filter(Boolean).join("");
-  if (ext === fileName) {
-    return "";
-  }
-  return ext || "txt";
-};
-
-// packages/core/src/lib/paths.ts
-var methods = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "trace",
-  "head"
-];
-var semanticSourceToOpenAPI = {
-  queries: "query",
-  query: "query",
-  headers: "header",
-  params: "path"
-};
-var Paths = class {
-  #commonZodImport;
-  #onOperation;
-  #operations = [];
-  constructor(config) {
-    this.#commonZodImport = config.commonZodImport;
-    this.#onOperation = config.onOperation;
-  }
-  addPath(name, path, method, contentType, selectors, responses, sourceFile, tags, description) {
-    const responsesObject = this.#responseItemToResponses(responses);
-    this.#operations.push({
-      name,
-      path: this.#tunePath(path),
-      sourceFile,
-      contentType,
-      method,
-      selectors,
-      responses: responsesObject,
-      tags,
-      description
-    });
-    return this;
-  }
-  #responseItemToResponses(responses) {
-    const responsesObject = {};
-    for (const item of responses) {
-      const ct = item.contentType;
-      const schema = item.response ? toSchema(item.response) : {};
-      if (!responsesObject[item.statusCode]) {
-        responsesObject[item.statusCode] = {
-          description: `Response for ${item.statusCode}`,
-          content: ct !== "empty" ? {
-            [ct]: ct === "application/octet-stream" ? { schema: { type: "string", format: "binary" } } : { schema }
-          } : void 0,
-          headers: item.headers.length ? item.headers.reduce((acc, current) => {
-            const headers = typeof current === "string" ? { [current]: [] } : current;
-            return Object.entries(headers).reduce(
-              (subAcc, [key, value]) => {
-                const header = {
-                  [key]: {
-                    schema: {
-                      type: "string",
-                      enum: value.length ? value : void 0
-                    }
-                  }
-                };
-                return { ...subAcc, ...header };
-              },
-              acc
-            );
-          }, {}) : void 0
-        };
-      } else {
-        if (!responsesObject[item.statusCode].content[ct]) {
-          responsesObject[item.statusCode].content[ct] = { schema };
-        } else {
-          const existing = responsesObject[item.statusCode].content[ct].schema;
-          if (existing.oneOf) {
-            if (!existing.oneOf.find(
-              (it) => JSON.stringify(it) === JSON.stringify(schema)
-            )) {
-              existing.oneOf.push(schema);
-            }
-          } else if (JSON.stringify(existing) !== JSON.stringify(schema)) {
-            responsesObject[item.statusCode].content[ct].schema = {
-              oneOf: [existing, schema]
-            };
-          }
-        }
-      }
-    }
-    return responsesObject;
-  }
-  async #selectosToParameters(selectors) {
-    const parameters = [];
-    const bodySchemaProps = {};
-    for (const selector of selectors) {
-      if (selector.source === "body") {
-        bodySchemaProps[selector.name] = {
-          required: selector.required,
-          schema: await evalZod(selector.against, this.#commonZodImport)
-        };
-        continue;
-      }
-      const parameter = {
-        in: semanticSourceToOpenAPI[selector.source],
-        name: selector.name,
-        required: selector.required,
-        schema: await evalZod(selector.against, this.#commonZodImport)
-      };
-      parameters.push(parameter);
-    }
-    return { parameters, bodySchemaProps };
-  }
-  async getPaths() {
-    const operations = {};
-    for (const operation of this.#operations) {
-      const { path, method, selectors } = operation;
-      const { parameters, bodySchemaProps } = await this.#selectosToParameters(selectors);
-      const bodySchema = {};
-      const required = [];
-      for (const [key, value] of Object.entries(bodySchemaProps)) {
-        if (value.required) {
-          required.push(key);
-        }
-        bodySchema[key] = value.schema;
-      }
-      const operationObject = {
-        operationId: operation.name,
-        parameters,
-        tags: operation.tags,
-        description: operation.description,
-        requestBody: Object.keys(bodySchema).length ? {
-          required: required.length ? true : false,
-          content: {
-            [operation.contentType || "application/json"]: {
-              schema: {
-                required: required.length ? required : void 0,
-                type: "object",
-                properties: bodySchema
-              }
-            }
-          }
-        } : void 0,
-        responses: Object.keys(operation.responses).length === 0 ? void 0 : operation.responses
-      };
-      if (!operations[path]) {
-        operations[path] = {};
-      }
-      operations[path][method] = operationObject;
-      if (this.#onOperation) {
-        const paths = this.#onOperation?.(
-          operation.sourceFile,
-          method,
-          path,
-          operationObject
-        );
-        Object.assign(operations, paths ?? {});
-      }
-    }
-    return operations;
-  }
-  /**
-   * Converts Express/Node.js style path parameters (/path/:param) to OpenAPI style (/path/{param})
-   */
-  #tunePath(path) {
-    return path.replace(/:([^/]+)/g, "{$1}");
-  }
-};
-async function evalZod(schema, commonZodImport) {
-  const lines = [
-    `import { createRequire } from "node:module";`,
-    `const filename = "${import.meta.url}";`,
-    `const require = createRequire(filename);`,
-    `const z = require("zod");`,
-    commonZodImport ? `const commonZod = require('${commonZodImport}');` : "",
-    `const {zodToJsonSchema} = require('zod-to-json-schema');`,
-    `const schema = ${schema.replace(".optional()", "").replaceAll("instanceof(File)", "string().base64()")};`,
-    `const jsonSchema = zodToJsonSchema(schema, {
-      $refStrategy: 'root',
-      basePath: ['#', 'components', 'schemas'],
-      target: 'jsonSchema7',
-      base64Strategy: 'format:binary',
-  });`,
-    `export default jsonSchema;`
-  ];
-  const base64 = Buffer.from(lines.join("\n")).toString("base64");
-  return import(`data:text/javascript;base64,${base64}`).then((mod) => mod.default).then(({ $schema, ...result }) => result);
-}
-function toSchema(data) {
-  if (data === null || data === void 0) {
-    return { type: "any" };
-  } else if (typeof data === "string") {
-    const isRef2 = data.startsWith("#");
-    if (isRef2) {
-      return { $ref: data };
-    }
-    return { type: data };
-  } else if (data.kind === "literal") {
-    return { enum: [data.value], type: data[$types][0] };
-  } else if (data.kind === "record") {
-    return {
-      type: "object",
-      additionalProperties: toSchema(data[$types][0])
-    };
-  } else if (data.kind === "array") {
-    const items = data[$types].map(toSchema);
-    return { type: "array", items: data[$types].length ? items[0] : {} };
-  } else if (data.kind === "union") {
-    return { anyOf: data[$types].map(toSchema) };
-  } else if (data.kind === "intersection") {
-    return { allOf: data[$types].map(toSchema) };
-  } else if ($types in data) {
-    return data[$types].map(toSchema)[0] ?? {};
-  } else {
-    const props = {};
-    const required = [];
-    for (const [key, value] of Object.entries(data)) {
-      props[key] = toSchema(value);
-      if (!value.optional) {
-        required.push(key);
-      }
-    }
-    return {
-      type: "object",
-      properties: props,
-      required,
-      additionalProperties: false
-    };
-  }
-}
-function isHttpMethod(name) {
-  return ["get", "post", "put", "delete", "patch"].includes(name);
-}
-
-// packages/core/src/lib/program.ts
-import debug from "debug";
-import { dirname as dirname2, join as join2 } from "node:path";
-import ts2 from "typescript";
-var logger = debug("january:client");
-function parseTsConfig(tsconfigPath) {
-  logger(`Using TypeScript version: ${ts2.version}`);
-  const configContent = ts2.readConfigFile(tsconfigPath, ts2.sys.readFile);
-  if (configContent.error) {
-    console.error(
-      `Failed to read tsconfig file:`,
-      ts2.formatDiagnosticsWithColorAndContext([configContent.error], {
-        getCanonicalFileName: (path) => path,
-        getCurrentDirectory: ts2.sys.getCurrentDirectory,
-        getNewLine: () => ts2.sys.newLine
-      })
-    );
-    throw new Error("Failed to parse tsconfig.json");
-  }
-  const parsed = ts2.parseJsonConfigFileContent(
-    configContent.config,
-    ts2.sys,
-    dirname2(tsconfigPath)
-  );
-  if (parsed.errors.length > 0) {
-    console.error(
-      `Errors found in tsconfig.json:`,
-      ts2.formatDiagnosticsWithColorAndContext(parsed.errors, {
-        getCanonicalFileName: (path) => path,
-        getCurrentDirectory: ts2.sys.getCurrentDirectory,
-        getNewLine: () => ts2.sys.newLine
-      })
-    );
-    throw new Error("Failed to parse tsconfig.json");
-  }
-  return parsed;
-}
-function getProgram(tsconfigPath) {
-  const tsConfigParseResult = parseTsConfig(tsconfigPath);
-  logger(`Parsing tsconfig`);
-  return ts2.createProgram({
-    options: {
-      ...tsConfigParseResult.options,
-      noEmit: true,
-      incremental: true,
-      tsBuildInfoFile: join2(dirname2(tsconfigPath), "./.tsbuildinfo")
-      // not working atm
-    },
-    rootNames: tsConfigParseResult.fileNames,
-    projectReferences: tsConfigParseResult.projectReferences,
-    configFileParsingDiagnostics: tsConfigParseResult.errors
-  });
-}
-function getPropertyAssignment(node, name) {
-  if (ts2.isObjectLiteralExpression(node)) {
-    return node.properties.filter((prop) => ts2.isPropertyAssignment(prop)).find((prop) => prop.name.getText() === name);
-  }
-  return void 0;
-}
-function isCallExpression(node, name) {
-  return ts2.isCallExpression(node) && node.expression && ts2.isIdentifier(node.expression) && node.expression.text === name;
-}
-function isInterfaceType2(type) {
-  if (type.isClassOrInterface()) {
-    return !!(type.symbol.flags & ts2.SymbolFlags.Interface);
-  }
-  return false;
-}
-
-// packages/core/src/lib/ref.ts
-import { get } from "lodash-es";
-function isRef(obj) {
-  return obj && "$ref" in obj;
-}
-function notRef(obj) {
-  return !isRef(obj);
-}
-function cleanRef(ref) {
-  return ref.replace(/^#\//, "");
-}
-function parseRef(ref) {
-  const parts = ref.split("/");
-  const [model] = parts.splice(-1);
-  const [namespace] = parts.splice(-1);
-  return {
-    model,
-    namespace,
-    path: cleanRef(parts.join("/"))
-  };
-}
-function followRef(spec, ref) {
-  const pathParts = cleanRef(ref).split("/");
-  const entry = get(spec, pathParts);
-  if (entry && "$ref" in entry) {
-    return followRef(spec, entry.$ref);
-  }
-  return entry;
-}
-
-// packages/core/src/index.ts
+export * from "./lib/deriver.js";
+export * from "./lib/paths.js";
+export * from "./lib/program.js";
+export * from "./lib/ref.js";
 function removeDuplicates(data, accessor = (item) => item) {
   return [...new Map(data.map((x) => [accessor(x), x])).values()];
 }
@@ -943,35 +35,11 @@ function snakecase(value) {
   return _snakecase(value.split("/").join(" "));
 }
 export {
-  $types,
-  Paths,
-  TypeDeriver,
-  cleanRef,
-  deriveSymbol,
-  exist,
-  followRef,
-  getExt,
-  getFile,
-  getFolderExports,
-  getFolderExportsV2,
-  getProgram,
-  getPropertyAssignment,
-  isCallExpression,
   isEmpty,
-  isHttpMethod,
-  isInterfaceType2 as isInterfaceType,
-  isRef,
-  methods,
-  notRef,
-  parseRef,
-  parseTsConfig,
   pascalcase,
-  readFolder,
   removeDuplicates,
   snakecase,
   spinalcase,
-  toLitObject,
-  toSchema,
-  writeFiles
+  toLitObject
 };
 //# sourceMappingURL=index.js.map