api-farmer 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -1,521 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  createStatusCodesByStrategy: () => createStatusCodesByStrategy,
-  createTransformer: () => createTransformer,
-  defineConfig: () => defineConfig,
-  findObjectKey: () => findObjectKey,
-  generate: () => generate,
-  generateTypes: () => generateTypes,
-  getCliVersion: () => getCliVersion,
-  getConfig: () => getConfig,
-  getRequestBodyContentType: () => getRequestBodyContentType,
-  getResponseMetadataItems: () => getResponseMetadataItems,
-  getSchemaNode: () => getSchemaNode,
-  isRemoteSchema: () => isRemoteSchema,
-  isRequiredRequestBody: () => isRequiredRequestBody,
-  partitionApiModules: () => partitionApiModules,
-  pluralize: () => import_pluralize2.default,
-  readSchema: () => readSchema,
-  readSchemaContent: () => readSchemaContent,
-  readTemplateFile: () => readTemplateFile,
-  renderApiModules: () => renderApiModules,
-  transformComment: () => transformComment,
-  transformEntity: () => transformEntity,
-  transformFn: () => transformFn,
-  transformModuleName: () => transformModuleName,
-  transformPayloads: () => transformPayloads,
-  transformType: () => transformType,
-  transformTypeQuery: () => transformTypeQuery,
-  transformTypeQueryValue: () => transformTypeQueryValue,
-  transformTypeRequestBody: () => transformTypeRequestBody,
-  transformTypeRequestBodyValue: () => transformTypeRequestBodyValue,
-  transformTypeResponseBody: () => transformTypeResponseBody,
-  transformTypeResponseBodyValue: () => transformTypeResponseBodyValue,
-  transformTypeValue: () => transformTypeValue,
-  transformUrl: () => transformUrl,
-  transformVerb: () => transformVerb
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/transformer.ts
-var import_pluralize = __toESM(require("pluralize"), 1);
-var import_rattail = require("rattail");
-function transformModuleName({ name }) {
-  return (0, import_rattail.camelize)(name);
-}
-function transformUrl({ path }) {
-  return path.replace(/{/g, ":").replace(/}/g, "");
-}
-function transformComment({
-  summary,
-  description,
-  path,
-  method
-}) {
-  return `
-  /**${summary ? `
-* ${summary}` : ""}${description && summary !== description ? `
-* @description ${description}
-*` : ""}
-   * @url ${path}
-   * @method ${method.toLocaleUpperCase()}
-   */
-  `.trim();
-}
-function transformVerb({ method }) {
-  switch (method) {
-    case "post":
-      return "Create";
-    case "put":
-      return "Update";
-    default:
-      return (0, import_rattail.pascalCase)(method);
-  }
-}
-function transformEntity({ path, method, uncountableNouns }) {
-  const words = path.split("/").filter(Boolean);
-  return words.reduce((entity, word, index) => {
-    if (word.includes("{")) {
-      return entity;
-    }
-    word = word.replace(/\.([a-z])/g, (_, p) => p.toUpperCase());
-    const isUncountableNoun = uncountableNouns.includes(word);
-    word = (0, import_rattail.pascalCase)(word);
-    word = isUncountableNoun ? word : import_pluralize.default.singular(word);
-    if (method === "get" && index === words.length - 1) {
-      word = isUncountableNoun ? `${word}List` : import_pluralize.default.plural(word);
-    }
-    return `${entity}${word}`;
-  }, "");
-}
-function transformFn({ verb, entity }) {
-  return `api${verb}${entity}`;
-}
-function transformType({ verb, entity }) {
-  return `Api${verb}${entity}`;
-}
-function transformTypeValue({ fullPath, method }) {
-  return `paths['${fullPath}']['${method}']`;
-}
-function transformTypeQuery({ type }) {
-  return `${type}Query`;
-}
-function transformTypeQueryValue({
-  type
-}) {
-  return `${type}['parameters']['query']`;
-}
-function transformTypeRequestBody({
-  type
-}) {
-  return `${type}RequestBody`;
-}
-function transformTypeRequestBodyValue({
-  type,
-  required,
-  requestContentType
-}) {
-  return required ? `${type}['requestBody']['content']['${requestContentType}']` : `NonNullable<${type}['requestBody']>['content']['${requestContentType}'] | undefined`;
-}
-function transformTypeResponseBody({
-  type
-}) {
-  return `${type}ResponseBody`;
-}
-function transformTypeResponseBodyValue({
-  type,
-  responseMetadataItems
-}) {
-  return responseMetadataItems.map(({ status, responseContentType }) => `${type}['responses']['${status}']['content']['${responseContentType}']`).join(" | ");
-}
-function createTransformer() {
-  return {
-    moduleName: transformModuleName,
-    verb: transformVerb,
-    url: transformUrl,
-    comment: transformComment,
-    entity: transformEntity,
-    fn: transformFn,
-    type: transformType,
-    typeValue: transformTypeValue,
-    typeQuery: transformTypeQuery,
-    typeQueryValue: transformTypeQueryValue,
-    typeRequestBody: transformTypeRequestBody,
-    typeRequestBodyValue: transformTypeRequestBodyValue,
-    typeResponseBody: transformTypeResponseBody,
-    typeResponseBodyValue: transformTypeResponseBodyValue
-  };
-}
-
-// src/generate.ts
-var import_path3 = require("path");
-var import_ejs = __toESM(require("ejs"), 1);
-var import_fs_extra2 = __toESM(require("fs-extra"), 1);
-var import_openapi_typescript = __toESM(require("openapi-typescript"), 1);
-var import_prettier = __toESM(require("prettier"), 1);
-var import_rattail3 = require("rattail");
-var import_rslog2 = require("rslog");
-var import_typescript = __toESM(require("typescript"), 1);
-
-// src/config.ts
-var import_unconfig = require("unconfig");
-function defineConfig(config) {
-  return config;
-}
-async function getConfig() {
-  const { config } = await (0, import_unconfig.loadConfig)({
-    sources: [
-      {
-        files: "api-farmer.config"
-      }
-    ]
-  });
-  return config ?? {};
-}
-
-// src/constants.ts
-var import_path = require("path");
-var CWD = process.cwd();
-var CUSTOM_TEMPLATE_FILE = (0, import_path.resolve)(CWD, `./api-farmer.ejs`);
-var CLI_PACKAGE_JSON = (0, import_path.resolve)(__dirname, "../package.json");
-var SUPPORTED_HTTP_METHODS = ["get", "post", "put", "delete", "patch", "options", "head"];
-
-// src/utils.ts
-var import_path2 = require("path");
-var import_axle = require("@varlet/axle");
-var import_fs_extra = __toESM(require("fs-extra"), 1);
-var import_rattail2 = require("rattail");
-var import_rslog = require("rslog");
-var import_swagger2openapi = __toESM(require("swagger2openapi"), 1);
-var import_yaml = __toESM(require("yaml"), 1);
-function createStatusCodesByStrategy(strategy) {
-  return {
-    strict: {
-      get: 200,
-      post: 201,
-      put: 200,
-      delete: 204,
-      patch: 200,
-      options: 204,
-      head: 200
-    },
-    loose: {
-      get: 200,
-      post: 200,
-      put: 200,
-      delete: 200,
-      patch: 200,
-      options: 200,
-      head: 200
-    },
-    smart: {
-      get: 200,
-      post: 200,
-      put: 200,
-      delete: 200,
-      patch: 200,
-      options: 200,
-      head: 200
-    }
-  }[strategy];
-}
-async function readSchema(input) {
-  const content = await readSchemaContent(input);
-  const jsonSchema = (0, import_rattail2.tryParseJSON)(content);
-  const swaggerOrOpenapiSchema = jsonSchema ? jsonSchema : import_yaml.default.parse(content);
-  const schema = swaggerOrOpenapiSchema.swagger ? (await import_swagger2openapi.default.convert(swaggerOrOpenapiSchema, {})).openapi : swaggerOrOpenapiSchema;
-  return schema;
-}
-function getSchemaNode(schema, path) {
-  const paths = path.split("/");
-  return paths.reduce((node, path2) => node[path2], schema);
-}
-async function readSchemaContent(input) {
-  if (isRemoteSchema(input)) {
-    try {
-      import_rslog.logger.info("Fetching remote schema...");
-      const { data } = await (0, import_axle.createAxle)().get(input);
-      return JSON.stringify(data);
-    } catch {
-      throw new Error("Failed to fetch remote schema");
-    }
-  }
-  const path = (0, import_path2.resolve)(CWD, input);
-  const content = import_fs_extra.default.readFileSync(path, "utf-8");
-  return content;
-}
-function isRemoteSchema(path) {
-  return path.startsWith("http://") || path.startsWith("https://");
-}
-function readTemplateFile(preset = "axle") {
-  if (import_fs_extra.default.existsSync(CUSTOM_TEMPLATE_FILE)) {
-    return import_fs_extra.default.readFileSync(CUSTOM_TEMPLATE_FILE, "utf-8");
-  }
-  return import_fs_extra.default.readFileSync((0, import_path2.resolve)(__dirname, `../templates/${preset}.ejs`), "utf-8");
-}
-function getCliVersion() {
-  return import_fs_extra.default.readJsonSync(CLI_PACKAGE_JSON).version;
-}
-function isRequiredRequestBody(value) {
-  return "required" in value && value.required === true;
-}
-function findObjectKey(object, targetKeys) {
-  return Object.keys(object).find((key) => targetKeys.includes(key));
-}
-function getRequestBodyContentType(value) {
-  if (!("content" in value)) {
-    return "";
-  }
-  return findObjectKey(value.content, ["application/json", "application/x-www-form-urlencoded", "multipart/form-data"]);
-}
-function getResponseMetadataItems(operation, validateStatus) {
-  const responses = operation.responses ?? {};
-  const validStatusResults = Object.keys(responses).sort((a, b) => Number(a) - Number(b)).filter((key) => validateStatus(Number(key))).map(Number);
-  const metadataItems = validStatusResults.map((status) => {
-    const content = operation.responses?.[status]?.content ?? {};
-    const responseContentType = findObjectKey(content, ["application/json", "application/octet-stream", "*/*"]);
-    return {
-      status,
-      responseContentType
-    };
-  }).filter((result) => result.responseContentType);
-  return metadataItems;
-}
-
-// src/generate.ts
-function transformPayloads(pathItems, options) {
-  const { transformer, path, fullPath, base, uncountableNouns, validateStatus, excludeDeprecated } = options;
-  return Object.entries(pathItems).filter(([key]) => SUPPORTED_HTTP_METHODS.includes(key)).filter(([, operation]) => !(excludeDeprecated && operation.deprecated)).reduce((payloads, [method, operation]) => {
-    const url = transformer.url({ path, base, fullPath });
-    const args = { path, base, fullPath, url, method, uncountableNouns, operation };
-    const entity = transformer.entity(args);
-    const verb = transformer.verb(args);
-    const comment = transformer.comment({ ...args, ...operation });
-    const requestContentType = operation.requestBody ? getRequestBodyContentType(operation.requestBody) : void 0;
-    const responseMetadataItems = getResponseMetadataItems(operation, validateStatus);
-    const fn = transformer.fn({ ...args, verb, entity });
-    const type = transformer.type({ ...args, verb, entity });
-    const typeValue = transformer.typeValue({ ...args, verb, entity });
-    const typeQuery = transformer.typeQuery({ ...args, type, verb, entity });
-    const typeQueryValue = transformer.typeQueryValue({ ...args, type, verb, entity });
-    const typeRequestBody = transformer.typeRequestBody({ ...args, type, verb, entity });
-    const typeRequestBodyValue = operation.requestBody && requestContentType ? transformer.typeRequestBodyValue({
-      ...args,
-      type,
-      verb,
-      entity,
-      required: isRequiredRequestBody(operation.requestBody),
-      requestContentType
-    }) : "undefined";
-    const typeResponseBody = transformer.typeResponseBody({ ...args, type, verb, entity });
-    const typeResponseBodyValue = responseMetadataItems.length > 0 ? transformer.typeResponseBodyValue({ ...args, type, verb, entity, responseMetadataItems }) : "undefined";
-    payloads.push({
-      comment,
-      fn,
-      url,
-      method,
-      verb,
-      entity,
-      requestContentType,
-      type,
-      typeValue,
-      typeQuery,
-      typeQueryValue,
-      typeRequestBody,
-      typeRequestBodyValue,
-      typeResponseBody,
-      typeResponseBodyValue
-    });
-    return payloads;
-  }, []);
-}
-function partitionApiModules(schema, options) {
-  const { base, transformer, uncountableNouns, validateStatus, excludeDeprecated } = options;
-  const schemaPaths = schema.paths ?? {};
-  const schemaPathKeys = base ? Object.keys(schemaPaths).map((key) => key.replace(base, "")) : Object.keys(schemaPaths);
-  const keyToPaths = (0, import_rattail3.groupBy)(schemaPathKeys, (key) => key.split("/")[1]);
-  const apiModules = Object.entries(keyToPaths).reduce((apiModules2, [name, paths]) => {
-    const payloads = paths.reduce((payloads2, path) => {
-      const fullPath = base ? base + path : path;
-      const pathItems = schemaPaths[fullPath];
-      payloads2.push(
-        ...transformPayloads(pathItems, {
-          ...options,
-          path,
-          fullPath,
-          transformer,
-          uncountableNouns,
-          validateStatus,
-          excludeDeprecated
-        })
-      );
-      return payloads2;
-    }, []);
-    apiModules2.push({ name: transformer.moduleName({ name }), payloads });
-    return apiModules2;
-  }, []);
-  return apiModules;
-}
-function renderApiModules(apiModules, options) {
-  const { output, ts: ts2, typesOnly, overrides, preset } = options;
-  const templateFile = readTemplateFile(preset);
-  const typesFilename = options.typesFilename.replace(".ts", "");
-  return Promise.all(
-    apiModules.map(
-      (apiModule) => new Promise((promiseResolve) => {
-        const data = {
-          apiModule,
-          typesFilename,
-          ts: ts2,
-          typesOnly
-        };
-        import_prettier.default.format(import_ejs.default.render(templateFile, data), {
-          parser: "typescript",
-          semi: false,
-          singleQuote: true,
-          printWidth: 120
-        }).then((content) => {
-          const path = (0, import_path3.resolve)(output, `${apiModule.name}.${ts2 ? "ts" : "js"}`);
-          const shouldSkip = (!overrides || (0, import_rattail3.isArray)(overrides) && !overrides.includes(apiModule.name)) && import_fs_extra2.default.existsSync(path);
-          if (shouldSkip) {
-            import_rslog2.logger.warn(`File already exists, skip: ${path}`);
-            promiseResolve(content);
-            return;
-          }
-          import_fs_extra2.default.outputFileSync(path, content);
-          import_rslog2.logger.success(`Generated ${path}`);
-          promiseResolve(content);
-        });
-      })
-    )
-  );
-}
-async function generateTypes(schema, output, typesFilename, openapiTsOptions) {
-  const BLOB = import_typescript.default.factory.createTypeReferenceNode(import_typescript.default.factory.createIdentifier("Blob"));
-  const NULL = import_typescript.default.factory.createLiteralTypeNode(import_typescript.default.factory.createNull());
-  const ast = await (0, import_openapi_typescript.default)(schema, {
-    defaultNonNullable: false,
-    transform(schemaObject) {
-      if (schemaObject.format === "binary") {
-        return schemaObject.nullable ? import_typescript.default.factory.createUnionTypeNode([BLOB, NULL]) : BLOB;
-      }
-    },
-    ...openapiTsOptions
-  });
-  const contents = (0, import_openapi_typescript.astToString)(ast);
-  const typesFilepath = (0, import_path3.resolve)(CWD, output, typesFilename);
-  import_fs_extra2.default.outputFileSync(typesFilepath, contents);
-  import_rslog2.logger.success(`Generated ${typesFilepath}`);
-}
-async function generate(userOptions = {}) {
-  const config = await getConfig();
-  const options = (0, import_rattail3.merge)(config, userOptions);
-  const {
-    base,
-    ts: ts2 = true,
-    typesOnly = false,
-    overrides = true,
-    preset = "axle",
-    input = "./schema.json",
-    output = "./src/apis/generated",
-    typesFilename = "_types.ts",
-    clean = false,
-    validateStatus = (status) => status >= 200 && status < 300,
-    transformer = {},
-    uncountableNouns = [],
-    openapiTsOptions = {},
-    excludeDeprecated = false
-  } = options;
-  const mergedTransformer = { ...createTransformer(), ...transformer };
-  const schema = await readSchema(input);
-  if (clean) {
-    import_fs_extra2.default.removeSync((0, import_path3.resolve)(CWD, output));
-    import_rslog2.logger.info(`Cleaned output directory: ${(0, import_path3.resolve)(CWD, output)}`);
-  }
-  import_rslog2.logger.info("Generating API modules...");
-  if (openapiTsOptions.excludeDeprecated === void 0) {
-    openapiTsOptions.excludeDeprecated = excludeDeprecated;
-  }
-  if (ts2) {
-    await generateTypes(schema, output, typesFilename, openapiTsOptions);
-  }
-  const apiModules = partitionApiModules(schema, {
-    base,
-    uncountableNouns,
-    transformer: mergedTransformer,
-    validateStatus,
-    excludeDeprecated
-  });
-  await renderApiModules(apiModules, { output, typesFilename, ts: ts2, typesOnly, overrides, preset });
-  import_rslog2.logger.success("Done");
-}
-
-// src/index.ts
-var import_pluralize2 = __toESM(require("pluralize"), 1);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createStatusCodesByStrategy,
-  createTransformer,
-  defineConfig,
-  findObjectKey,
-  generate,
-  generateTypes,
-  getCliVersion,
-  getConfig,
-  getRequestBodyContentType,
-  getResponseMetadataItems,
-  getSchemaNode,
-  isRemoteSchema,
-  isRequiredRequestBody,
-  partitionApiModules,
-  pluralize,
-  readSchema,
-  readSchemaContent,
-  readTemplateFile,
-  renderApiModules,
-  transformComment,
-  transformEntity,
-  transformFn,
-  transformModuleName,
-  transformPayloads,
-  transformType,
-  transformTypeQuery,
-  transformTypeQueryValue,
-  transformTypeRequestBody,
-  transformTypeRequestBodyValue,
-  transformTypeResponseBody,
-  transformTypeResponseBodyValue,
-  transformTypeValue,
-  transformUrl,
-  transformVerb
-});