@byyuurin/nitro-openapi 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Yuurin<https://github.com/byyuurin>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @byyuurin/nitro-openapi

package/dist/index.d.mts

@@ -0,0 +1,64 @@
+import * as openapi_typescript from 'openapi-typescript';
+import { ReferenceObject, PathItemObject, OperationObject, SecurityRequirementObject, OpenAPI3, SchemaObject } from 'openapi-typescript';
+
+type ReferenceSchema<T> = Omit<ReferenceObject, '$ref'> & {
+    $ref: T;
+};
+type MaybeReference<T, R = string> = T | ReferenceSchema<R>;
+type PathOperations = Omit<PathItemObject, 'servers' | 'parameters' | `x-${string}`>;
+type PathOperationMethod = keyof PathOperations;
+type PathOperationItem<T extends OpenApiRegisterConfig = Required<OpenApiRegisterConfig>> = Omit<OperationObject, 'security' | 'tags'> & {
+    tags?: T extends {
+        tags: infer Tags;
+    } ? Tags extends ({
+        name: infer Tag;
+    })[] ? Tag[] | string[] : string[] : string[];
+    security?: T extends {
+        components: infer C;
+    } ? C extends {
+        securitySchemes: infer S;
+    } ? {
+        [SecurityName in keyof S]?: string[];
+    }[] : SecurityRequirementObject[] : SecurityRequirementObject[];
+};
+type OpenApiRegisterConfig = Pick<Partial<OpenAPI3>, 'paths' | 'components' | 'security' | 'servers' | 'info' | 'tags'>;
+
+declare function createOpenApiRegister<T extends OpenApiRegisterConfig = OpenApiRegisterConfig>(defaults?: T): {
+    configExtends: T;
+    register: (route: string, routeOperation: MaybeReference<PathOperationItem<T>>, method?: keyof PathOperations) => void;
+    merge: (config: Partial<OpenAPI3>) => {
+        info: openapi_typescript.InfoObject | undefined;
+    };
+};
+
+type SchemaObjectOptions = SchemaObject & {
+    allowExample?: boolean;
+};
+declare function resolveSchemaObject(value: any, options?: SchemaObjectOptions): SchemaObject;
+type ExampleDescription<ExampleT> = ExampleT extends number | string | boolean ? string : ExampleT extends (infer ArrayT)[] ? string | ExampleDescription<ArrayT> : ExampleT extends Record<infer PropertyT, unknown> ? {
+    [key in PropertyT]?: string;
+} | string : string;
+declare function toExampleSchema<T = any>(example: T, description?: ExampleDescription<T>): {
+    [key: `x-${string}`]: any;
+    discriminator?: openapi_typescript.DiscriminatorObject | undefined;
+    xml?: openapi_typescript.XMLObject | undefined;
+    externalDocs?: openapi_typescript.ExternalDocumentationObject | undefined;
+    example?: any;
+    title?: string | undefined;
+    description?: string | undefined;
+    $comment?: string | undefined;
+    deprecated?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    writeOnly?: boolean | undefined;
+    enum?: unknown[] | undefined;
+    const?: unknown;
+    default?: unknown;
+    format?: string | undefined;
+    nullable?: boolean | undefined;
+    oneOf?: (openapi_typescript.ReferenceObject | SchemaObject)[] | undefined;
+    allOf?: (openapi_typescript.ReferenceObject | SchemaObject)[] | undefined;
+    anyOf?: (openapi_typescript.ReferenceObject | SchemaObject)[] | undefined;
+    required?: string[] | undefined;
+};
+
+export { type MaybeReference, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type ReferenceSchema, createOpenApiRegister, resolveSchemaObject, toExampleSchema };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import * as openapi_typescript from 'openapi-typescript';
+import { ReferenceObject, PathItemObject, OperationObject, SecurityRequirementObject, OpenAPI3, SchemaObject } from 'openapi-typescript';
+
+type ReferenceSchema<T> = Omit<ReferenceObject, '$ref'> & {
+    $ref: T;
+};
+type MaybeReference<T, R = string> = T | ReferenceSchema<R>;
+type PathOperations = Omit<PathItemObject, 'servers' | 'parameters' | `x-${string}`>;
+type PathOperationMethod = keyof PathOperations;
+type PathOperationItem<T extends OpenApiRegisterConfig = Required<OpenApiRegisterConfig>> = Omit<OperationObject, 'security' | 'tags'> & {
+    tags?: T extends {
+        tags: infer Tags;
+    } ? Tags extends ({
+        name: infer Tag;
+    })[] ? Tag[] | string[] : string[] : string[];
+    security?: T extends {
+        components: infer C;
+    } ? C extends {
+        securitySchemes: infer S;
+    } ? {
+        [SecurityName in keyof S]?: string[];
+    }[] : SecurityRequirementObject[] : SecurityRequirementObject[];
+};
+type OpenApiRegisterConfig = Pick<Partial<OpenAPI3>, 'paths' | 'components' | 'security' | 'servers' | 'info' | 'tags'>;
+
+declare function createOpenApiRegister<T extends OpenApiRegisterConfig = OpenApiRegisterConfig>(defaults?: T): {
+    configExtends: T;
+    register: (route: string, routeOperation: MaybeReference<PathOperationItem<T>>, method?: keyof PathOperations) => void;
+    merge: (config: Partial<OpenAPI3>) => {
+        info: openapi_typescript.InfoObject | undefined;
+    };
+};
+
+type SchemaObjectOptions = SchemaObject & {
+    allowExample?: boolean;
+};
+declare function resolveSchemaObject(value: any, options?: SchemaObjectOptions): SchemaObject;
+type ExampleDescription<ExampleT> = ExampleT extends number | string | boolean ? string : ExampleT extends (infer ArrayT)[] ? string | ExampleDescription<ArrayT> : ExampleT extends Record<infer PropertyT, unknown> ? {
+    [key in PropertyT]?: string;
+} | string : string;
+declare function toExampleSchema<T = any>(example: T, description?: ExampleDescription<T>): {
+    [key: `x-${string}`]: any;
+    discriminator?: openapi_typescript.DiscriminatorObject | undefined;
+    xml?: openapi_typescript.XMLObject | undefined;
+    externalDocs?: openapi_typescript.ExternalDocumentationObject | undefined;
+    example?: any;
+    title?: string | undefined;
+    description?: string | undefined;
+    $comment?: string | undefined;
+    deprecated?: boolean | undefined;
+    readOnly?: boolean | undefined;
+    writeOnly?: boolean | undefined;
+    enum?: unknown[] | undefined;
+    const?: unknown;
+    default?: unknown;
+    format?: string | undefined;
+    nullable?: boolean | undefined;
+    oneOf?: (openapi_typescript.ReferenceObject | SchemaObject)[] | undefined;
+    allOf?: (openapi_typescript.ReferenceObject | SchemaObject)[] | undefined;
+    anyOf?: (openapi_typescript.ReferenceObject | SchemaObject)[] | undefined;
+    required?: string[] | undefined;
+};
+
+export { type MaybeReference, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type ReferenceSchema, createOpenApiRegister, resolveSchemaObject, toExampleSchema };

package/dist/index.mjs

@@ -0,0 +1,151 @@
+import defu from 'defu';
+
+function createOpenApiRegister(defaults = {}) {
+  const { paths = {}, components = {}, security = [], servers = [], info, tags = [] } = defaults;
+  function register(route, routeOperation, method = "get") {
+    const _route = normalizeRoute(route);
+    paths[_route] = defu(
+      { [method]: routeOperation },
+      paths[_route]
+    );
+  }
+  function merge(config) {
+    return mergeConfig(
+      config,
+      {
+        paths,
+        components,
+        security,
+        servers,
+        info,
+        tags
+      }
+    );
+  }
+  return {
+    configExtends: {
+      paths,
+      components,
+      security,
+      servers,
+      info,
+      tags
+    },
+    register,
+    merge
+  };
+}
+function normalizeRoute(_route) {
+  let anonymousCtr = 0;
+  const route = _route.replace(/:(\w+)/g, (_, name) => `{${name}}`).replace(/\/(\*)\//g, () => `/{param${++anonymousCtr}}/`).replace(/\*\*{/, "{").replace(/\/(\*\*)$/g, () => `/{*param${++anonymousCtr}}`);
+  return route;
+}
+function mergeConfig(defaults, appends) {
+  const methods = /* @__PURE__ */ new Set(["delete", "get", "head", "options", "patch", "post", "put", "trace"]);
+  const { info } = appends;
+  const { paths = {} } = defaults;
+  for (const path in paths) {
+    const operations = paths[path];
+    if ("$ref" in operations)
+      continue;
+    paths[path] = Object.fromEntries(Object.entries(operations).map(([key, obj]) => {
+      if (methods.has(key))
+        return [key, normalizeSchema(obj)];
+      return [key, obj];
+    }));
+  }
+  return defu({ info }, defaults, appends);
+}
+function normalizeSchema(obj) {
+  if ("$ref" in obj)
+    return obj;
+  const { parameters = [] } = obj;
+  obj.parameters = parameters.map((p) => {
+    if ("$ref" in p)
+      return p;
+    return defu(p, {
+      schema: { type: "string" }
+    });
+  });
+  return obj;
+}
+
+function resolveSchemaObject(value, options = {}) {
+  const { allowExample = true, ...defaults } = options;
+  const { description: _, ...inheritOptions } = options;
+  const resolveResult = (obj, example) => {
+    if (allowExample && example != null)
+      obj.example = example;
+    return { ...defaults, ...obj };
+  };
+  if (Array.isArray(value)) {
+    return resolveResult(
+      {
+        type: "array",
+        items: resolveSchemaObject(value[0], { ...inheritOptions, allowExample: false })
+      },
+      value
+    );
+  }
+  const _type = typeof value;
+  switch (_type) {
+    case "function":
+    case "symbol":
+    case "undefined":
+      return { type: "null" };
+    case "object":
+      return resolveResult(
+        {
+          type: "object",
+          properties: Object.fromEntries(Object.entries(value).map(([k, v]) => [
+            k,
+            resolveSchemaObject(v, {
+              ...inheritOptions,
+              allowExample: false
+            })
+          ]))
+        },
+        value
+      );
+    case "bigint":
+      return resolveResult(
+        { type: "integer" },
+        value
+      );
+    case "string":
+      return resolveResult(
+        { type: "string" },
+        value || null
+      );
+    default:
+      return resolveResult(
+        { type: _type },
+        value
+      );
+  }
+}
+function toExampleSchema(example, description) {
+  if (typeof example !== "object") {
+    return resolveSchemaObject(
+      example,
+      typeof description === "string" ? { description } : {}
+    );
+  }
+  if (Array.isArray(example)) {
+    if (typeof description === "string")
+      return resolveSchemaObject(example, { description });
+    const schema2 = resolveSchemaObject(example, { allowExample: false });
+    schema2.items = toExampleSchema(example[0], description);
+    return schema2;
+  }
+  if (typeof description === "string")
+    return resolveSchemaObject(example, { description });
+  const schema = resolveSchemaObject(example);
+  schema.properties = Object.fromEntries(Object.entries(schema.properties).map(([p, item]) => [p, {
+    ...item,
+    ...typeof description === "object" ? { description: description?.[p] } : {}
+  }]));
+  return schema;
+}
+
+export { createOpenApiRegister, resolveSchemaObject, toExampleSchema };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@byyuurin/nitro-openapi",
+  "type": "module",
+  "version": "0.0.1",
+  "private": false,
+  "license": "MIT",
+  "homepage": "https://github.com/byyuurin/nitro-openapi",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/byyuurin/nitro-openapi.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "*.d.ts",
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "prepare": "nitropack prepare",
+    "dev": "nitropack dev playground",
+    "dev:build": "nitropack build playground",
+    "dev:preview": "node playground/.output/server/index.mjs",
+    "lint": "eslint .",
+    "test": "vitest",
+    "release": "bumpp && pnpm publish",
+    "stub": "unbuild --stub"
+  },
+  "dependencies": {
+    "defu": "^6.1.4",
+    "openapi-typescript": "^6.7.4"
+  },
+  "devDependencies": {
+    "@byyuurin/eslint-config": "^1.0.1",
+    "bumpp": "^9.3.0",
+    "nitropack": "latest",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.3.0"
+  },
+  "resolutions": {
+    "@byyuurin/nitro-openapi": "link:."
+  }
+}