api-farmer 0.0.19 → 0.0.21

package/README.md

@@ -210,6 +210,10 @@ export interface ApiModulePayload {
    * such as User, Comment, Post, etc.
    */
   entity: string
+  /**
+   * The request content type of the API endpoint, such as 'application/json', 'application/x-www-form-urlencoded'.
+   */
+  requestContentType?: string
   /**
    * The type name of the API endpoint,
    * such as ApiGetUsers, ApiCreatePost, ApiUpdateComment, etc.

package/dist/chunk-GMB5TIVL.js

@@ -0,0 +1,285 @@
+import {
+  CWD,
+  SUPPORTED_HTTP_METHODS,
+  getRequestBodyContentType,
+  getResponseMetadataItems,
+  hasQueryParameter,
+  isRequiredRequestBody,
+  readSchema,
+  readTemplateFile
+} from "./chunk-PTGO2Y5X.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";
+
+// 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, base }) {
+  return (base ? path.replace(base, "") : path).replace(/{/g, ":").replace(/}/g, "");
+}
+function transformVerb({ method }) {
+  switch (method) {
+    case "post":
+      return "Create";
+    case "put":
+      return "Update";
+    default:
+      return pascalCase(method);
+  }
+}
+function transformEntity({ path, method, base }) {
+  path = base ? path.replace(base, "") : path;
+  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());
+    word = pluralize.singular(pascalCase(word));
+    if (method === "get" && index === words.length - 1) {
+      word = pluralize.plural(word);
+    }
+    return `${entity}${word}`;
+  }, "");
+}
+function transformFn({ verb, entity }) {
+  return `api${verb}${entity}`;
+}
+function transformType({ verb, entity }) {
+  return `Api${verb}${entity}`;
+}
+function transformTypeValue({ path, method }) {
+  return `paths['${path}']['${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,
+    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, base, validateStatus } = options;
+  return Object.entries(pathItems).filter(([key]) => SUPPORTED_HTTP_METHODS.includes(key)).reduce((payloads, [method, operation]) => {
+    const url = transformer.url({ path, base });
+    const args = { path, base, url, method, operation };
+    const entity = transformer.entity(args);
+    const verb = transformer.verb(args);
+    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 = hasQueryParameter(operation) ? transformer.typeQueryValue({ ...args, type, verb, entity }) : "undefined";
+    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({
+      fn,
+      url,
+      method,
+      verb,
+      entity,
+      requestContentType,
+      type,
+      typeValue,
+      typeQuery,
+      typeQueryValue,
+      typeRequestBody,
+      typeRequestBodyValue,
+      typeResponseBody,
+      typeResponseBodyValue
+    });
+    return payloads;
+  }, []);
+}
+function partitionApiModules(schema, options) {
+  const { base, transformer, validateStatus } = 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 pathItems = schemaPaths[path];
+      payloads2.push(
+        ...transformPayloads(pathItems, { ...options, path: base ? base + path : path, transformer, validateStatus })
+      );
+      return payloads2;
+    }, []);
+    apiModules2.push({ name: transformer.moduleName({ name }), payloads });
+    return apiModules2;
+  }, []);
+  return apiModules;
+}
+function renderApiModules(apiModules, options) {
+  const { output, ts, 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,
+          typesOnly
+        };
+        prettier.format(ejs.render(templateFile, data), {
+          parser: "typescript",
+          semi: false,
+          singleQuote: true,
+          printWidth: 120
+        }).then((content) => {
+          const path = resolve(output, `${apiModule.name}.${ts ? "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) {
+  const ast = await openapiTS(schema);
+  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 = true,
+    typesOnly = false,
+    overrides = true,
+    preset = "axle",
+    input = "./schema.json",
+    output = "./src/apis/generated",
+    typesFilename = "_types.ts",
+    validateStatus = (status) => status >= 200 && status < 300,
+    transformer = {}
+  } = options;
+  const mergedTransformer = { ...createTransformer(), ...transformer };
+  const schema = await readSchema(input);
+  logger.info("Generating API modules...");
+  if (ts) {
+    await generateTypes(schema, output, typesFilename);
+  }
+  const apiModules = partitionApiModules(schema, {
+    base,
+    transformer: mergedTransformer,
+    validateStatus
+  });
+  await renderApiModules(apiModules, { output, typesFilename, ts, typesOnly, overrides, preset });
+  logger.success("Done");
+}
+
+export {
+  defineConfig,
+  getConfig,
+  transformModuleName,
+  transformUrl,
+  transformVerb,
+  transformEntity,
+  transformFn,
+  transformType,
+  transformTypeValue,
+  transformTypeQuery,
+  transformTypeQueryValue,
+  transformTypeRequestBody,
+  transformTypeRequestBodyValue,
+  transformTypeResponseBody,
+  transformTypeResponseBodyValue,
+  createTransformer,
+  transformPayloads,
+  partitionApiModules,
+  renderApiModules,
+  generateTypes,
+  generate
+};

package/dist/{chunk-SKKHIIUE.js → chunk-PTGO2Y5X.js}

@@ -1,6 +1,9 @@
-import {
-  __dirname
-} from "./chunk-6OIOYGN7.js";
+// 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";
@@ -11,7 +14,10 @@ var SUPPORTED_HTTP_METHODS = ["get", "post", "put", "delete", "patch", "options"
 
 // 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) {
@@ -46,13 +52,29 @@ function createStatusCodesByStrategy(strategy) {
   }[strategy];
 }
 async function readSchema(input) {
-  const isYaml = input.endsWith(".yaml");
-  const path = resolve2(CWD, input);
-  const content = fse.readFileSync(path, "utf-8");
-  const swaggerOrOpenapiSchema = isYaml ? yaml.parse(content) : JSON.parse(content);
+  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;
 }
+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");
@@ -68,18 +90,27 @@ function getCliVersion() {
 function isRequiredRequestBody(value) {
   return "required" in value && value.required === true;
 }
-function getValidResponseMetadataItems(operation, validateStatus) {
+function getRequestBodyContentType(value) {
+  if (!("content" in value)) {
+    return "";
+  }
+  return value.content["application/json"] ? "application/json" : value.content["application/x-www-form-urlencoded"] ? "application/x-www-form-urlencoded" : void 0;
+}
+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 results = validStatusResults.map((status) => {
-    const content = operation.responses?.[status]?.content;
-    const mime = content?.["application/json"] ? "application/json" : content?.["*/*"] ? "*/*" : void 0;
+  const metadataItems = validStatusResults.map((status) => {
+    const content = operation.responses?.[status]?.content ?? {};
+    const responseContentType = findResponseContentType(content);
     return {
       status,
-      mime
+      responseContentType
     };
-  }).filter((result) => result.mime);
-  return results;
+  }).filter((result) => result.responseContentType);
+  function findResponseContentType(content) {
+    return content["application/json"] ? "application/json" : content["*/*"] ? "*/*" : void 0;
+  }
+  return metadataItems;
 }
 
 export {
@@ -87,9 +118,12 @@ export {
   SUPPORTED_HTTP_METHODS,
   createStatusCodesByStrategy,
   readSchema,
+  readSchemaContent,
+  isRemoteSchema,
   readTemplateFile,
   hasQueryParameter,
   getCliVersion,
   isRequiredRequestBody,
-  getValidResponseMetadataItems
+  getRequestBodyContentType,
+  getResponseMetadataItems
 };