@automatons/parser 0.0.263 → 1.0.1

package/index.js

@@ -1,19 +1,634 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./parser"), exports);
-__exportStar(require("./types"), exports);
+// src/converters/security.ts
+import { camelCase } from "change-case";
+var convertSecurity = (name, security, scopes) => {
+  switch (security.type) {
+    case "apiKey":
+      return { ...security, name: camelCase(name), key: security.name };
+    case "http":
+      return { ...security, name: camelCase(name) };
+    case "oauth2":
+    case "openIdConnect":
+      return { ...security, name: camelCase(name), scopes };
+    default:
+      return void 0;
+  }
+};
+
+// src/parsers/api.ts
+import { camelCase as camelCase4, pascalCase as pascalCase9 } from "change-case";
+
+// src/converters/map.ts
+var convertMap = (map = {}) => Object.entries(map).map(([key, schema]) => ({ key, schema }));
+
+// src/extractors/model/index.ts
+import {
+  isSchemaAllOf as isSchemaAllOf2,
+  isSchemaArray as isSchemaArray2,
+  isSchemaBoolean as isSchemaBoolean2,
+  isSchemaInteger as isSchemaInteger2,
+  isSchemaNumber as isSchemaNumber2,
+  isSchemaObject as isSchemaObject2,
+  isSchemaOneOf as isSchemaOneOf2,
+  isSchemaRef as isSchemaRef2,
+  isSchemaString as isSchemaString2
+} from "@automatons/tools";
+
+// src/converters/schema.ts
+var convertSchema = (schema) => ({
+  description: schema.description,
+  nullable: schema.nullable,
+  readOnly: schema.readOnly,
+  writeOnly: schema.writeOnly,
+  deprecated: schema.deprecated,
+  example: schema.example,
+  defaultValue: schema.default
+});
+
+// src/converters/boolean.ts
+var convertBoolean = (schema) => ({
+  type: "boolean",
+  ...convertSchema(schema)
+});
+
+// src/converters/model.ts
+import { camelCase as camelCase2, pascalCase } from "change-case";
+var convertModel = (title, schema, imports = []) => ({
+  title: pascalCase(title),
+  filename: camelCase2(title),
+  imports,
+  schema
+});
+
+// src/converters/number.ts
+var convertNumber = (schema) => ({
+  type: "number",
+  format: schema.format,
+  ...convertSchema(schema),
+  enum: schema.enum ?? []
+});
+
+// src/converters/string.ts
+var convertString = (schema) => ({
+  type: "string",
+  format: schema.format,
+  enum: schema.enum ?? [],
+  ...convertSchema(schema)
+});
+
+// src/converters/allOf.ts
+var convertAllOf = (schema, schemas) => ({
+  type: "allOf",
+  ...convertSchema(schema),
+  schemas
+});
+
+// src/extractors/schema/index.ts
+import {
+  isSchemaAllOf,
+  isSchemaArray,
+  isSchemaBoolean,
+  isSchemaInteger,
+  isSchemaNumber,
+  isSchemaObject,
+  isSchemaOneOf,
+  isSchemaRef,
+  isSchemaString
+} from "@automatons/tools";
+
+// src/converters/schemaModel.ts
+import { pascalCase as pascalCase2 } from "change-case";
+var convertSchemaModel = (model, schema) => ({
+  type: "model",
+  name: pascalCase2(model),
+  ...convertSchema(schema)
+});
+
+// src/extractors/schema/number.ts
+var extractNumberSchema = (title, schema) => {
+  if (schema.title) {
+    const modelSchema = convertSchemaModel(title, schema);
+    const models = [convertModel(title, convertNumber(schema))];
+    return { schema: modelSchema, models, imports: models };
+  }
+  return { schema: convertNumber(schema), models: [] };
+};
+
+// src/extractors/schema/array.ts
+import { pascalCase as pascalCase3 } from "change-case";
+
+// src/converters/array.ts
+var convertArray = (schema, itemSchema) => ({
+  type: "array",
+  ...convertSchema(schema),
+  uniqueItems: schema.uniqueItems,
+  minItems: schema.minItems,
+  maxItems: schema.maxItems,
+  items: itemSchema
+});
+
+// src/extractors/schema/array.ts
+var extractArraySchema = async (title, schema, context) => {
+  const models = [];
+  const imports = [];
+  let itemSchema = void 0;
+  if (schema.items) {
+    const { schema: shm, models: itemModels, imports: itemImports } = await extractSchema(pascalCase3([title, "Item"].join(" ")), schema.items, context);
+    itemSchema = shm;
+    models.push(...itemModels);
+    imports.push(...itemImports ?? []);
+  }
+  if (schema.title) {
+    const modelSchema = convertSchemaModel(title, schema);
+    const model = convertModel(title, convertArray(schema, itemSchema));
+    return { schema: modelSchema, models: [model, ...models], imports: [...models] };
+  }
+  return {
+    schema: convertArray(schema, itemSchema),
+    models,
+    imports
+  };
+};
+
+// src/extractors/schema/object.ts
+var extractObjectSchema = async (title, schema, context) => {
+  const modelSchema = convertSchemaModel(title, schema);
+  const { model, insides } = await extractModel(title, schema, context);
+  return {
+    schema: modelSchema,
+    models: [model, ...insides],
+    imports: [convertModel(title, modelSchema)]
+  };
+};
+
+// src/extractors/schema/allOf.ts
+var extractAllOfSchema = async (title, schema, context) => {
+  const modelSchema = convertSchemaModel(title, schema);
+  const { model, insides } = await extractModel(title, schema, context);
+  return {
+    schema: modelSchema,
+    models: [model, ...insides],
+    imports: [convertModel(title, modelSchema)]
+  };
+};
+
+// src/extractors/schema/oneOf.ts
+var extractOneOfSchema = async (title, schema, context) => {
+  const modelSchema = convertSchemaModel(title, schema);
+  const { model, insides } = await extractModel(title, schema, context);
+  return {
+    schema: modelSchema,
+    models: [model, ...insides],
+    imports: [convertModel(title, modelSchema)]
+  };
+};
+
+// src/extractors/schema/ref.ts
+import { referenceTitle } from "@automatons/tools";
+var extractRefSchema = (title, schema) => {
+  const name = referenceTitle(schema) ?? title;
+  const modelSchema = convertSchemaModel(name, schema);
+  return {
+    schema: modelSchema,
+    models: [],
+    imports: [convertModel(name, modelSchema)]
+  };
+};
+
+// src/extractors/schema/string.ts
+var extractStringSchema = (title, schema) => {
+  if (schema.title) {
+    const modelSchema = convertSchemaModel(title, schema);
+    const models = [convertModel(title, convertString(schema))];
+    return { schema: modelSchema, models, imports: models };
+  }
+  return { schema: convertString(schema), models: [] };
+};
+
+// src/extractors/schema/boolean.ts
+var extractBooleanSchema = (title, schema) => {
+  if (schema.title) {
+    const modelSchema = convertSchemaModel(title, schema);
+    const models = [convertModel(title, convertBoolean(schema))];
+    return { schema: modelSchema, models, imports: models };
+  }
+  return { schema: convertBoolean(schema), models: [] };
+};
+
+// src/extractors/schema/index.ts
+var extractSchema = async (title, schema, context) => {
+  if (isSchemaString(schema)) {
+    return extractStringSchema(title, schema);
+  } else if (isSchemaNumber(schema) || isSchemaInteger(schema)) {
+    return extractNumberSchema(title, schema);
+  } else if (isSchemaBoolean(schema)) {
+    return extractBooleanSchema(title, schema);
+  } else if (isSchemaArray(schema)) {
+    return extractArraySchema(title, schema, context);
+  } else if (isSchemaObject(schema)) {
+    return extractObjectSchema(title, schema, context);
+  } else if (isSchemaAllOf(schema)) {
+    return extractAllOfSchema(title, schema, context);
+  } else if (isSchemaOneOf(schema)) {
+    return extractOneOfSchema(title, schema, context);
+  } else if (isSchemaRef(schema)) {
+    return extractRefSchema(title, schema);
+  }
+  throw new Error(`Unknown type
+${JSON.stringify(schema, void 0, 2)}`);
+};
+
+// src/extractors/model/of.ts
+import { pascalCase as pascalCase4 } from "change-case";
+var extractOfModel = (title, schemas, context) => {
+  return schemas.map((item, index) => extractSchema(pascalCase4([title, index].join(" ")), item, context)).reduce(async (pre, cur) => ({
+    schemas: [...(await pre).schemas, (await cur).schema],
+    models: [...(await pre).models, ...(await cur).models],
+    imports: [...(await pre).imports, ...(await cur).imports ?? []]
+  }), Promise.resolve({ schemas: [], models: [], imports: [] }));
+};
+
+// src/extractors/model/allOf.ts
+var extractAllOfModel = async (title, schema, context) => {
+  const { models, schemas, imports } = await extractOfModel(title, schema.allOf, context);
+  return { model: convertModel(title, convertAllOf(schema, schemas), imports), insides: models };
+};
+
+// src/extractors/model/array.ts
+import { pascalCase as pascalCase5 } from "change-case";
+var extractArrayModel = async (title, schema, context) => {
+  if (schema.items) {
+    const { schema: shm, models, imports } = await extractSchema(pascalCase5([title, "Item"].join(" ")), schema.items, context);
+    return { model: convertModel(title, convertArray(schema, shm), imports), insides: models };
+  }
+  return { model: convertModel(title, convertArray(schema)), insides: [] };
+};
+
+// src/extractors/model/object.ts
+import { pascalCase as pascalCase6 } from "change-case";
+
+// src/converters/object.ts
+var convertObjectSchema = (schema, properties) => ({
+  type: "object",
+  ...convertSchema(schema),
+  properties
+});
+
+// src/extractors/model/object.ts
+var extractObjectModel = async (title, schema, context) => {
+  const models = [];
+  const imports = [];
+  const propertySchemas = schema.properties;
+  const properties = await Promise.all(convertMap(propertySchemas).map(async ({ key, schema: propertySchema }) => {
+    const extractPropertySchema = await extractSchema(pascalCase6([title, key].join(" ")), propertySchema, context);
+    models.push(...extractPropertySchema.models);
+    imports.push(...extractPropertySchema.imports ?? []);
+    return { name: key, required: schema.required?.includes(key) ?? false, schema: extractPropertySchema.schema };
+  }));
+  return { model: convertModel(title, convertObjectSchema(schema, properties), imports), insides: models };
+};
+
+// src/converters/oneOf.ts
+var convertOneOf = (schema, schemas) => ({
+  type: "oneOf",
+  ...convertSchema(schema),
+  schemas
+});
+
+// src/extractors/model/oneOf.ts
+var extractOneOfModel = async (title, schema, context) => {
+  const { models, schemas, imports } = await extractOfModel(title, schema.oneOf, context);
+  return { model: convertModel(title, convertOneOf(schema, schemas), imports), insides: models };
+};
+
+// src/extractors/model/ref.ts
+import {
+  referenceSchema,
+  referenceTitle as referenceTitle2
+} from "@automatons/tools";
+var extractRefModel = async (title, schema, context) => {
+  const refSchema = await referenceSchema(schema, context);
+  const refTitle = referenceTitle2(schema);
+  const ref = convertSchemaModel(refTitle, refSchema);
+  return { model: convertModel(title, ref, [convertModel(refTitle, ref)]), insides: [] };
+};
+
+// src/extractors/model/index.ts
+var extractModel = async (title, schema, context) => {
+  if (isSchemaString2(schema)) {
+    return { model: convertModel(title, convertString(schema)), insides: [] };
+  } else if (isSchemaNumber2(schema) || isSchemaInteger2(schema)) {
+    return { model: convertModel(title, convertNumber(schema)), insides: [] };
+  } else if (isSchemaBoolean2(schema)) {
+    return { model: convertModel(title, convertBoolean(schema)), insides: [] };
+  } else if (isSchemaArray2(schema)) {
+    return extractArrayModel(title, schema, context);
+  } else if (isSchemaObject2(schema)) {
+    return extractObjectModel(title, schema, context);
+  } else if (isSchemaAllOf2(schema)) {
+    return extractAllOfModel(title, schema, context);
+  } else if (isSchemaOneOf2(schema)) {
+    return extractOneOfModel(title, schema, context);
+  } else if (isSchemaRef2(schema)) {
+    return extractRefModel(title, schema, context);
+  }
+  throw new Error(`Unknown type
+${JSON.stringify(schema, void 0, 2)}`);
+};
+
+// src/extractors/path/index.ts
+import { HTTP_METHODS } from "@automatons/tools";
+
+// src/extractors/path/method.ts
+import { camelCase as camelCase3 } from "change-case";
+
+// src/converters/server.ts
+import { pascalCase as pascalCase7 } from "change-case";
+var convertServer = (schema) => ({
+  name: pascalCase7(schema["x-name"] ?? schema.url),
+  url: schema.url,
+  values: convertMap(schema.variables).map(({ key, schema: schema2 }) => ({ name: key, defaultValue: schema2.default, enums: schema2.enum }))
+});
+
+// src/utils/sort.ts
+var requiredCompare = (a, b) => a.required && b.required || !a.required && !b.required ? 0 : b.required ? 1 : -1;
+
+// src/extractors/path/parameter.ts
+import {
+  hasSchema,
+  isCookieParam,
+  isHeaderParam,
+  isPathParam,
+  isQueryParam,
+  referenceSchema as referenceSchema2
+} from "@automatons/tools";
+import { pascalCase as pascalCase8 } from "change-case";
+
+// src/extractors/path/mediaType.ts
+var extractMediaType = (schema) => Object.hasOwn(schema, "application/json") ? "application/json" : Object.hasOwn(schema, "application/*") ? "application/*" : Object.hasOwn(schema, "default") ? "default" : Object.keys(schema)[0] ?? "";
+
+// src/extractors/path/parameter.ts
+var extractParameter = (schema, { path, ...context }) => schema.map((param) => referenceSchema2(param, context)).map(async (param) => {
+  const _param = await param;
+  const paramSchema = hasSchema(_param) ? _param.schema : Object.keys(_param.content).length ? _param.content[extractMediaType(_param.content)]?.schema : void 0;
+  if (!paramSchema) return;
+  const { schema: schema2, models, imports } = await extractSchema(
+    pascalCase8([path, "parameter", _param.name].join(" ")),
+    paramSchema,
+    context
+  );
+  if (isPathParam(_param)) {
+    return {
+      parameter: {
+        name: _param.name,
+        schema: schema2,
+        style: _param.style,
+        explode: _param.explode
+      },
+      models,
+      imports
+    };
+  } else if (isQueryParam(_param)) {
+    return {
+      query: {
+        name: _param.name,
+        schema: schema2,
+        style: _param.style,
+        required: _param.required,
+        explode: _param.explode
+      },
+      models,
+      imports
+    };
+  } else if (isHeaderParam(_param)) {
+    return {
+      header: {
+        name: _param.name,
+        schema: schema2,
+        style: _param.style,
+        required: _param.required,
+        explode: _param.explode
+      },
+      models,
+      imports
+    };
+  } else if (isCookieParam(_param)) {
+    return {
+      cookie: {
+        name: _param.name,
+        schema: schema2,
+        style: _param.style,
+        required: _param.required,
+        explode: _param.explode
+      },
+      models,
+      imports
+    };
+  }
+  return;
+}).reduce(async (pre, cur) => {
+  const previous = await pre;
+  const current = await cur;
+  return current ? {
+    parameters: current.parameter ? [...previous.parameters, current.parameter] : previous.parameters,
+    queries: current.query ? [...previous.queries, current.query] : previous.queries,
+    headers: current.header ? [...previous.headers, current.header] : previous.headers,
+    cookies: current.cookie ? [...previous.cookies, current.cookie] : previous.cookies,
+    models: [...previous.models, ...current.models],
+    imports: [...previous.imports, ...current.imports ?? []]
+  } : previous;
+}, Promise.resolve({ parameters: [], queries: [], headers: [], cookies: [], models: [], imports: [] }));
+
+// src/extractors/path/requestBody.ts
+import {
+  referenceSchema as referenceSchema3
+} from "@automatons/tools";
+import { isDeepStrictEqual } from "util";
+var extractRequestBody = async (schema, path, method, context) => {
+  const requestBody = await referenceSchema3(schema, context);
+  const extracts = await Promise.all(Object.entries(requestBody.content).filter(
+    (item) => !!item[1].schema
+  ).map(async ([key, value]) => ({
+    key,
+    required: requestBody.required,
+    extract: await extractSchema(
+      [...path.split("/"), method, ...key.split("/"), "Request"].join(" "),
+      value.schema,
+      context
+    )
+  })));
+  return extracts.map(({ key, required, extract }) => ({
+    form: { types: [key], required, schema: extract.schema },
+    models: extract.models,
+    imports: extract.imports
+  })).reduce((pre, cur) => ({
+    forms: pre.forms.some((form) => isDeepStrictEqual(form.schema, cur.form.schema)) ? pre.forms.map(
+      (form) => isDeepStrictEqual(form.schema, cur.form.schema) ? {
+        ...form,
+        types: [...form.types, ...cur.form.types]
+      } : form
+    ) : [...pre.forms, cur.form],
+    models: [...pre.models, ...cur.models],
+    imports: [...pre.imports, ...cur.imports ?? []]
+  }), { forms: [], models: [], imports: [] });
+};
+
+// src/extractors/path/response.ts
+import { referenceSchema as referenceSchema4 } from "@automatons/tools";
+
+// src/extractors/path/status.ts
+var extractStatus = (schema) => {
+  const statuses = Object.keys(schema);
+  return statuses.map((status) => Number(status)).filter((status) => Number(status) >= 200 && Number(status) < 300).sort()[0] ?? statuses[0] ?? "";
+};
+
+// src/extractors/path/response.ts
+var extractResponse = async (schema, method, context) => {
+  const status = extractStatus(schema);
+  const response = await referenceSchema4(schema[status], context);
+  const content = response.content;
+  if (!content || !Object.keys(content).length) return;
+  const resSchema = content[extractMediaType(content)]?.schema;
+  if (!resSchema) return;
+  return extractSchema(
+    [...context.path.split("/"), method, "Response"].join(" "),
+    resSchema,
+    context
+  );
+};
+
+// src/extractors/path/security.ts
+var extractSecurity = (operation, openapi) => operation.security && operation.security.map((value) => Object.entries(value).map(([name, scopes]) => {
+  const security = openapi.components?.securitySchemes?.[name];
+  return security ? convertSecurity(name, security, scopes) : void 0;
+}).filter((value2) => value2 !== void 0)).flat();
+
+// src/extractors/path/method.ts
+var mergeModels = (main, adding) => {
+  main.models.push(...adding.models);
+  main.imports.push(...adding.imports);
+};
+var mergeParameter = async (parameters, path, params, models, { openapi, settings }) => {
+  const {
+    parameters: _parameters,
+    queries: _queries,
+    headers: _headers,
+    cookies: _cookies,
+    models: _models,
+    imports: _imports
+  } = await extractParameter(parameters, { path, openapi, settings });
+  params.parameters.push(..._parameters);
+  params.queries.push(..._queries);
+  params.headers.push(..._headers);
+  params.cookies.push(..._cookies);
+  mergeModels(models, { models: _models, imports: _imports });
+};
+var extractMethod = async (path, method, operation, schema, { openapi, settings }) => {
+  const models = {
+    models: [],
+    imports: []
+  };
+  const params = {
+    parameters: [],
+    queries: [],
+    headers: [],
+    cookies: []
+  };
+  const data = {
+    params,
+    servers: (operation.servers || schema.servers || openapi.servers || []).map(convertServer),
+    securities: extractSecurity(operation, openapi)
+  };
+  if (schema.parameters) {
+    await mergeParameter(schema.parameters, path, params, models, { openapi, settings });
+  }
+  if (operation.parameters) {
+    await mergeParameter(operation.parameters, path, params, models, { openapi, settings });
+  }
+  if (operation.requestBody) {
+    const bodies = await extractRequestBody(operation.requestBody, path, method, { openapi, settings });
+    data.forms = bodies.forms;
+    mergeModels(models, { models: bodies.models, imports: bodies.imports });
+  }
+  const response = await extractResponse(operation.responses, method, { path, openapi, settings });
+  if (response) {
+    data.schema = response.schema;
+    mergeModels(models, { models: response.models, imports: response.imports ?? [] });
+  }
+  return convertPath(path, method, operation, data, models);
+};
+var convertPath = (path, method, operation, { params, servers, securities, forms, schema }, models) => ({
+  tags: operation.tags && operation.tags.length ? operation.tags : ["default"],
+  path: {
+    name: camelCase3(operation.operationId ?? [method, ...path.split("/")].join(" ")),
+    path,
+    method,
+    servers,
+    parameters: params.parameters,
+    queries: params.queries.sort(requiredCompare),
+    headers: params.headers.sort(requiredCompare),
+    cookies: params.cookies.sort(requiredCompare),
+    ...securities ? { securities } : {},
+    ...forms ? { forms } : {},
+    ...schema ? { schema } : {}
+  },
+  ...models
+});
+
+// src/extractors/path/index.ts
+import { isRef, referenceSchema as referenceSchema5 } from "@automatons/tools";
+
+// src/utils/omitCopy.ts
+var omitCopy = (schema, key) => Object.entries(schema).reduce((pre, [name, value]) => ({ ...pre, ...name !== key ? { [name]: value } : {} }), {});
+
+// src/extractors/path/index.ts
+var extractPath = async (schema, { path, openapi, settings }) => {
+  const _schema = isRef(schema) ? { ...await referenceSchema5(schema, { openapi, settings }), ...omitCopy(schema, "$ref") } : schema;
+  return Promise.all(HTTP_METHODS.map((method) => ({ method, operation: _schema[method] })).filter(
+    (operation) => !!operation.operation
+  ).map(({ method, operation }) => extractMethod(path, method, operation, _schema, { openapi, settings })));
+};
+
+// src/utils/uniq.ts
+var uniq = (items, key) => items.reduce(
+  (pre, cur) => pre.some((item) => cur[key] === item[key]) ? pre : [...pre, cur],
+  []
+);
+
+// src/utils/overwrite.ts
+var overwrite = (items, item, predicate) => [...items.filter(predicate), item];
+
+// src/parsers/api.ts
+var parseApi = async ({ openapi, settings }) => {
+  const paths = (await Promise.all(convertMap(openapi.paths).map(({ key, schema }) => extractPath(schema, { path: key, openapi, settings })))).flat();
+  return {
+    apis: paths.reduce((apis, path) => path.tags.reduce((_apis, tag) => {
+      const title = pascalCase9([tag, "Api"].join(" "));
+      const api = _apis.find((api2) => api2.title === title);
+      return overwrite(_apis, createApi(title, path.path, path.imports, api), (item) => item.title !== title);
+    }, apis), []),
+    models: paths.reduce((models, cur) => uniq([...models, ...cur.models], "title"), [])
+  };
+};
+var createApi = (title, path, imports, base) => ({
+  title: pascalCase9(title),
+  filename: camelCase4(title),
+  imports: uniq([...base?.imports ?? [], ...imports], "title"),
+  servers: uniq([...base?.servers ?? [], ...path.servers], "name"),
+  paths: [...base?.paths ?? [], path]
+});
+
+// src/parsers/model.ts
+import { pascalCase as pascalCase10 } from "change-case";
+var parseModel = async (context) => (await Promise.all(convertMap(context.openapi.components?.schemas).map(({ key, schema }) => ({ title: pascalCase10(key), schema })).map(async ({ title, schema }) => Object.values(await extractModel(title, schema, context))))).flat(2);
+
+// src/parser.ts
+var parser = async (openapi, settings) => {
+  const { apis, models } = await parseApi({ openapi, settings });
+  models.push(...await parseModel({ openapi, settings }));
+  const securities = Object.entries(openapi.components?.securitySchemes ?? {}).map(([key, schema]) => convertSecurity(key, schema, [])).filter((value) => value !== void 0);
+  return { models, apis, securities };
+};
+export {
+  parser
+};
 //# sourceMappingURL=index.js.map