api-farmer 0.0.19 → 0.0.20

package/dist/chunk-5YXY7GCE.js

@@ -0,0 +1,280 @@
+import {
+  CWD,
+  SUPPORTED_HTTP_METHODS,
+  getValidResponseMetadataItems,
+  hasQueryParameter,
+  isRequiredRequestBody,
+  readSchema,
+  readTemplateFile
+} from "./chunk-NFK24PSA.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
+}) {
+  return required ? `${type}['requestBody']['content']['application/json']` : `NonNullable<${type}['requestBody']>['content']['application/json'] | undefined`;
+}
+function transformTypeResponseBody({
+  type
+}) {
+  return `${type}ResponseBody`;
+}
+function transformTypeResponseBodyValue({
+  type,
+  responseMetadataItems
+}) {
+  return responseMetadataItems.map(({ status, mime }) => `${type}['responses']['${status}']['content']['${mime}']`).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 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 ? transformer.typeRequestBodyValue({
+      ...args,
+      type,
+      verb,
+      entity,
+      required: isRequiredRequestBody(operation.requestBody)
+    }) : "undefined";
+    const typeResponseBody = transformer.typeResponseBody({ ...args, type, verb, entity });
+    const responseMetadataItems = getValidResponseMetadataItems(operation, validateStatus);
+    const typeResponseBodyValue = responseMetadataItems.length > 0 ? transformer.typeResponseBodyValue({ ...args, type, verb, entity, responseMetadataItems }) : "undefined";
+    payloads.push({
+      fn,
+      url,
+      method,
+      verb,
+      entity,
+      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-NFK24PSA.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";
@@ -47,8 +50,8 @@ function createStatusCodesByStrategy(strategy) {
 }
 async function readSchema(input) {
   const isYaml = input.endsWith(".yaml");
-  const path = resolve2(CWD, input);
-  const content = fse.readFileSync(path, "utf-8");
+  const path2 = resolve2(CWD, input);
+  const content = fse.readFileSync(path2, "utf-8");
   const swaggerOrOpenapiSchema = isYaml ? yaml.parse(content) : JSON.parse(content);
   const schema = swaggerOrOpenapiSchema.swagger ? (await swagger.convert(swaggerOrOpenapiSchema, {})).openapi : swaggerOrOpenapiSchema;
   return schema;