@sdk-it/core 0.12.7 → 0.12.9

package/dist/index 5.js

@@ -0,0 +1,732 @@
+// packages/core/src/lib/deriver.ts
+import ts, { TypeFlags, symbolName } from "typescript";
+var deriveSymbol = Symbol.for("serialize");
+var $types = Symbol.for("types");
+var defaults = {
+  ReadableStream: "any",
+  DateConstructor: "string",
+  ArrayBufferConstructor: "any",
+  SharedArrayBufferConstructor: "any",
+  Int8ArrayConstructor: "any",
+  Uint8Array: "any"
+};
+var TypeDeriver = class {
+  collector = {};
+  checker;
+  constructor(checker) {
+    this.checker = checker;
+  }
+  serializeType(type) {
+    if (type.flags & TypeFlags.Any) {
+      return {
+        [deriveSymbol]: true,
+        optional: false,
+        [$types]: []
+      };
+    }
+    if (type.flags & ts.TypeFlags.Boolean) {
+      return {
+        [deriveSymbol]: true,
+        optional: false,
+        [$types]: ["boolean"]
+      };
+    }
+    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.Null) {
+      return {
+        [deriveSymbol]: true,
+        optional: true,
+        [$types]: ["null"]
+      };
+    }
+    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) {
+          if ((prop.getDeclarations() ?? []).some(
+            (it) => ts.isPropertySignature(it) || ts.isPropertyAssignment(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);
+    }
+    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);
+      }
+      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 || node.kind === ts.SyntaxKind.FalseKeyword) {
+      return {
+        [deriveSymbol]: true,
+        optional: 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/program.ts
+import debug from "debug";
+import { dirname, join } 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,
+    dirname(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: join(dirname(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/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, selectors, responses, sourceFile, tags, description) {
+    const responsesObject = this.#responseItemToResponses(responses);
+    this.#operations.push({
+      name,
+      path,
+      sourceFile,
+      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]: ct === "application/octet-stream" ? { schema: { type: "string", format: "binary" } } : { schema }
+          },
+          headers: item.headers.length ? item.headers.reduce(
+            (acc, header) => ({
+              ...acc,
+              [header]: { schema: { type: "string" } }
+            }),
+            {}
+          ) : 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] = 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 operationObject = {
+        operationId: operation.name,
+        parameters,
+        tags: operation.tags,
+        description: operation.description,
+        requestBody: Object.keys(bodySchemaProps).length ? {
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: bodySchemaProps
+              }
+            }
+          }
+        } : void 0,
+        responses: operation.responses
+      };
+      if (!operations[path]) {
+        operations[path] = {};
+      }
+      operations[path][method] = operationObject;
+      if (this.#onOperation) {
+        const operations2 = this.#onOperation?.(
+          operation.sourceFile,
+          method,
+          path,
+          operationObject
+        );
+        Object.assign(operations2, operations2 ?? {});
+      }
+    }
+    return operations;
+  }
+};
+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 ? `import * as commonZod from '${commonZodImport}';` : "",
+    `const {zodToJsonSchema} = require('zod-to-json-schema');`,
+    `const schema = ${schema.replace(".optional()", "")};`,
+    `const jsonSchema = zodToJsonSchema(schema, {
+    	$refStrategy: 'root',
+    	basePath: ['#', 'components', 'schemas']
+    });`,
+    `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 isRef = data.startsWith("#");
+    if (isRef) {
+      return { $ref: data };
+    }
+    return { type: data };
+  } 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 { oneOf: 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 = {};
+    for (const [key, value] of Object.entries(data)) {
+      props[key] = toSchema(value);
+    }
+    return {
+      type: "object",
+      properties: props,
+      additionalProperties: false
+    };
+  }
+}
+function isHttpMethod(name) {
+  return ["get", "post", "put", "delete", "patch"].includes(name);
+}
+
+// packages/core/src/lib/file-system.ts
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute, join as join2 } 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) {
+  return Promise.all(
+    Object.entries(contents).map(async ([file, content]) => {
+      const filePath = isAbsolute(file) ? file : join2(dir, file);
+      await mkdir(dirname2(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");
+          }
+        }
+      }
+    })
+  );
+}
+async function getFolderExports(folder, extensions = ["ts"]) {
+  const files = await readdir(folder, { withFileTypes: true });
+  const exports = [];
+  for (const file of files) {
+    if (file.isDirectory()) {
+      exports.push(`export * from './${file.name}';`);
+    } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
+      exports.push(`export * from './${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/index.ts
+function removeDuplicates(data, accessor) {
+  return [...new Map(data.map((x) => [accessor(x), x])).values()];
+}
+function toLitObject(obj, accessor = (value) => value) {
+  return `{${Object.keys(obj).map((key) => `${key}: ${accessor(obj[key])}`).join(", ")}}`;
+}
+export {
+  $types,
+  Paths,
+  TypeDeriver,
+  deriveSymbol,
+  exist,
+  getExt,
+  getFile,
+  getFolderExports,
+  getProgram,
+  getPropertyAssignment,
+  isCallExpression,
+  isHttpMethod,
+  isInterfaceType2 as isInterfaceType,
+  methods,
+  parseTsConfig,
+  readFolder,
+  removeDuplicates,
+  toLitObject,
+  toSchema,
+  writeFiles
+};
+//# sourceMappingURL=index.js.map