api-farmer 0.1.3 → 0.1.4

package/dist/chunk-2227C45C.js

@@ -1,131 +0,0 @@
-// node_modules/.pnpm/tsup@8.3.5_jiti@2.4.2_postcss@8.5.1_tsx@4.19.2_typescript@5.3.3_yaml@2.7.0/node_modules/tsup/assets/esm_shims.js
-import { fileURLToPath } from "url";
-import path from "path";
-var getFilename = () => fileURLToPath(import.meta.url);
-var getDirname = () => path.dirname(getFilename());
-var __dirname = /* @__PURE__ */ getDirname();
-
-// src/constants.ts
-import { resolve } from "path";
-var CWD = process.cwd();
-var CUSTOM_TEMPLATE_FILE = resolve(CWD, `./api-farmer.ejs`);
-var CLI_PACKAGE_JSON = resolve(__dirname, "../package.json");
-var SUPPORTED_HTTP_METHODS = ["get", "post", "put", "delete", "patch", "options", "head"];
-
-// src/utils.ts
-import { resolve as resolve2 } from "path";
-import { createAxle } from "@varlet/axle";
-import fse from "fs-extra";
-import { tryParseJSON } from "rattail";
-import { logger } from "rslog";
-import swagger from "swagger2openapi";
-import yaml from "yaml";
-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 = tryParseJSON(content);
-  const swaggerOrOpenapiSchema = jsonSchema ? jsonSchema : yaml.parse(content);
-  const schema = swaggerOrOpenapiSchema.swagger ? (await swagger.convert(swaggerOrOpenapiSchema, {})).openapi : swaggerOrOpenapiSchema;
-  return schema;
-}
-function getSchemaNode(schema, path2) {
-  const paths = path2.split("/");
-  return paths.reduce((node, path3) => node[path3], schema);
-}
-async function readSchemaContent(input) {
-  if (isRemoteSchema(input)) {
-    try {
-      logger.info("Fetching remote schema...");
-      const { data } = await createAxle().get(input);
-      return JSON.stringify(data);
-    } catch {
-      throw new Error("Failed to fetch remote schema");
-    }
-  }
-  const path2 = resolve2(CWD, input);
-  const content = fse.readFileSync(path2, "utf-8");
-  return content;
-}
-function isRemoteSchema(path2) {
-  return path2.startsWith("http://") || path2.startsWith("https://");
-}
-function readTemplateFile(preset = "axle") {
-  if (fse.existsSync(CUSTOM_TEMPLATE_FILE)) {
-    return fse.readFileSync(CUSTOM_TEMPLATE_FILE, "utf-8");
-  }
-  return fse.readFileSync(resolve2(__dirname, `../templates/${preset}.ejs`), "utf-8");
-}
-function getCliVersion() {
-  return fse.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;
-}
-
-export {
-  CWD,
-  SUPPORTED_HTTP_METHODS,
-  createStatusCodesByStrategy,
-  readSchema,
-  getSchemaNode,
-  readSchemaContent,
-  isRemoteSchema,
-  readTemplateFile,
-  getCliVersion,
-  isRequiredRequestBody,
-  findObjectKey,
-  getRequestBodyContentType,
-  getResponseMetadataItems
-};

package/dist/chunk-RIXLRGPZ.js

@@ -1,338 +0,0 @@
-import {
-  CWD,
-  SUPPORTED_HTTP_METHODS,
-  getRequestBodyContentType,
-  getResponseMetadataItems,
-  isRequiredRequestBody,
-  readSchema,
-  readTemplateFile
-} from "./chunk-2227C45C.js";
-
-// src/generate.ts
-import { resolve } from "path";
-import ejs from "ejs";
-import fse from "fs-extra";
-import openapiTS, { astToString } from "openapi-typescript";
-import prettier from "prettier";
-import { groupBy, isArray, merge } from "rattail";
-import { logger } from "rslog";
-import ts from "typescript";
-
-// src/config.ts
-import { loadConfig } from "unconfig";
-function defineConfig(config) {
-  return config;
-}
-async function getConfig() {
-  const { config } = await loadConfig({
-    sources: [
-      {
-        files: "api-farmer.config"
-      }
-    ]
-  });
-  return config ?? {};
-}
-
-// src/transformer.ts
-import pluralize from "pluralize";
-import { camelize, pascalCase } from "rattail";
-function transformModuleName({ name }) {
-  return 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 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 = pascalCase(word);
-    word = isUncountableNoun ? word : pluralize.singular(word);
-    if (method === "get" && index === words.length - 1) {
-      word = isUncountableNoun ? `${word}List` : pluralize.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
-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 = 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
-        };
-        prettier.format(ejs.render(templateFile, data), {
-          parser: "typescript",
-          semi: false,
-          singleQuote: true,
-          printWidth: 120
-        }).then((content) => {
-          const path = resolve(output, `${apiModule.name}.${ts2 ? "ts" : "js"}`);
-          const shouldSkip = (!overrides || isArray(overrides) && !overrides.includes(apiModule.name)) && fse.existsSync(path);
-          if (shouldSkip) {
-            logger.warn(`File already exists, skip: ${path}`);
-            promiseResolve(content);
-            return;
-          }
-          fse.outputFileSync(path, content);
-          logger.success(`Generated ${path}`);
-          promiseResolve(content);
-        });
-      })
-    )
-  );
-}
-async function generateTypes(schema, output, typesFilename, openapiTsOptions) {
-  const BLOB = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Blob"));
-  const NULL = ts.factory.createLiteralTypeNode(ts.factory.createNull());
-  const ast = await openapiTS(schema, {
-    defaultNonNullable: false,
-    transform(schemaObject) {
-      if (schemaObject.format === "binary") {
-        return schemaObject.nullable ? ts.factory.createUnionTypeNode([BLOB, NULL]) : BLOB;
-      }
-    },
-    ...openapiTsOptions
-  });
-  const contents = astToString(ast);
-  const typesFilepath = resolve(CWD, output, typesFilename);
-  fse.outputFileSync(typesFilepath, contents);
-  logger.success(`Generated ${typesFilepath}`);
-}
-async function generate(userOptions = {}) {
-  const config = await getConfig();
-  const options = 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) {
-    fse.removeSync(resolve(CWD, output));
-    logger.info(`Cleaned output directory: ${resolve(CWD, output)}`);
-  }
-  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 });
-  logger.success("Done");
-}
-
-export {
-  defineConfig,
-  getConfig,
-  transformModuleName,
-  transformUrl,
-  transformComment,
-  transformVerb,
-  transformEntity,
-  transformFn,
-  transformType,
-  transformTypeValue,
-  transformTypeQuery,
-  transformTypeQueryValue,
-  transformTypeRequestBody,
-  transformTypeRequestBodyValue,
-  transformTypeResponseBody,
-  transformTypeResponseBodyValue,
-  createTransformer,
-  transformPayloads,
-  partitionApiModules,
-  renderApiModules,
-  generateTypes,
-  generate
-};