@elysiajs/openapi 1.3.2

package/dist/cjs/gen/index.js

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gen/index.ts
+var gen_exports = {};
+__export(gen_exports, {
+  fromTypes: () => fromTypes
+});
+module.exports = __toCommonJS(gen_exports);
+var import_fs = require("fs");
+var import_typemap = require("@sinclair/typemap");
+var import_os = require("os");
+var import_path = require("path");
+var import_child_process = require("child_process");
+var matchRoute = /: Elysia<(.*)>/gs;
+var matchStatus = /(\d{3}):/gs;
+var wrapStatusInQuote = (value) => value.replace(matchStatus, '"$1":');
+var exec = (command, cwd) => (0, import_child_process.spawnSync)(command, {
+  shell: true,
+  cwd,
+  stdio: "inherit"
+});
+var fromTypes = (targetFilePath, {
+  tsconfigPath = "tsconfig.json",
+  instanceName,
+  projectRoot = process.cwd()
+} = {}) => () => {
+  if (!targetFilePath.endsWith(".ts") && !targetFilePath.endsWith(".tsx"))
+    throw new Error("Only .ts files are supported");
+  const tmpRoot = (0, import_path.join)((0, import_os.tmpdir)(), ".ElysiaAutoOpenAPI");
+  if ((0, import_fs.existsSync)(tmpRoot))
+    (0, import_fs.rmSync)(tmpRoot, { recursive: true, force: true });
+  (0, import_fs.mkdirSync)(tmpRoot, { recursive: true });
+  const extendsRef = (0, import_fs.existsSync)((0, import_path.join)(projectRoot, "tsconfig.json")) ? `"extends": "${(0, import_path.join)(projectRoot, "tsconfig.json")}",` : "";
+  if (!(0, import_path.join)(projectRoot, targetFilePath))
+    throw new Error("Target file does not exist");
+  (0, import_fs.writeFileSync)(
+    (0, import_path.join)(tmpRoot, tsconfigPath),
+    `{
+			${extendsRef}
+			"compilerOptions": {
+				"lib": ["ESNext"],
+				"module": "ESNext",
+				"noEmit": false,
+				"moduleResolution": "bundler",
+				"skipLibCheck": true,
+				"skipDefaultLibCheck": true,
+				"emitDeclarationOnly": true,
+				"outDir": "./dist"
+			},
+			"include": ["${(0, import_path.join)(projectRoot, targetFilePath)}"]
+		}`
+  );
+  exec(`tsc`, tmpRoot);
+  try {
+    const declaration = (0, import_fs.readFileSync)(
+      (0, import_path.join)(
+        tmpRoot,
+        "dist",
+        targetFilePath.replace(/.tsx$/, ".ts").replace(/.ts$/, ".d.ts")
+      ),
+      "utf8"
+    );
+    if ((0, import_fs.existsSync)(tmpRoot))
+      (0, import_fs.rmSync)(tmpRoot, { recursive: true, force: true });
+    let instance = declaration.match(
+      instanceName ? new RegExp(`${instanceName}: Elysia<(.*)`, "gs") : matchRoute
+    )?.[0];
+    if (!instance) return;
+    for (let i = 0; i < 3; i++)
+      instance = instance.slice(instance.indexOf("}, {", 3));
+    const routesString = wrapStatusInQuote(instance).slice(
+      3,
+      instance.indexOf("}, {", 3)
+    ) + "}\n}\n";
+    const routes = {};
+    for (let route of routesString.slice(1).split("} & {")) {
+      route = "{" + route + "}";
+      let schema = (0, import_typemap.TypeBox)(route);
+      if (schema.type !== "object") continue;
+      const paths = [];
+      while (true) {
+        const keys = Object.keys(schema.properties);
+        if (!keys.length || keys.length > 1) break;
+        paths.push(keys[0]);
+        schema = schema.properties[keys[0]];
+        if (!schema?.properties) break;
+      }
+      const method = paths.pop();
+      const path = "/" + paths.join("/");
+      schema = schema.properties;
+      if (schema?.response?.type === "object") {
+        const responseSchema = {};
+        for (const key in schema.response.properties)
+          responseSchema[key] = schema.response.properties[key];
+        schema.response = responseSchema;
+      }
+      if (!routes[path]) routes[path] = {};
+      routes[path][method.toLowerCase()] = schema;
+    }
+    return routes;
+  } catch (error) {
+    console.warn("Failed to generate OpenAPI schema");
+    console.warn(error);
+    return;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fromTypes
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,35 @@
+import { Elysia } from 'elysia';
+import type { ElysiaOpenAPIConfig, OpenAPIProvider } from './types';
+/**
+ * Plugin for [elysia](https://github.com/elysiajs/elysia) that auto-generate OpenAPI documentation page.
+ *
+ * @see https://github.com/elysiajs/elysia-swagger
+ */
+export declare const openapi: <const Enabled extends boolean = true, const Path extends string = "/openapi", const Provider extends OpenAPIProvider = "scalar">({ enabled, path, provider, specPath, documentation, exclude, swagger, scalar, references }?: ElysiaOpenAPIConfig<Enabled, Path, Provider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+}>;
+export { toOpenAPISchema, withHeaders } from './openapi';
+export type { ElysiaOpenAPIConfig };
+export default openapi;