@byyuurin/nitro-openapi 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -0,0 +1,159 @@
+'use strict';
+
+const defu = require('defu');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const defu__default = /*#__PURE__*/_interopDefaultCompat(defu);
+
+function createOpenApiRegister(defaults) {
+  const { paths = {}, components = {}, security = [], servers = [], info, tags = [] } = defaults;
+  const defineOperation = (operation) => operation;
+  function register(route, routeOperation, method = "get") {
+    const _route = normalizeRoute(route);
+    paths[_route] = defu__default(
+      { [method]: routeOperation },
+      paths[_route]
+    );
+  }
+  function merge(config) {
+    return mergeConfig(
+      config,
+      {
+        paths,
+        components,
+        security,
+        servers,
+        info,
+        tags
+      }
+    );
+  }
+  return {
+    configExtends: {
+      paths,
+      components,
+      security,
+      servers,
+      info,
+      tags
+    },
+    defineOperation,
+    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__default({ 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__default(p, {
+      schema: { type: "string" }
+    });
+  });
+  return obj;
+}
+
+function resolveSchemaObject(value, options = {}) {
+  const { allowExample = true, ...defaults } = 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], { 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, {
+              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, options) {
+  if (typeof example !== "object") {
+    return resolveSchemaObject(
+      example,
+      typeof description === "string" ? { ...options, description } : {}
+    );
+  }
+  if (Array.isArray(example)) {
+    if (typeof description === "string")
+      return resolveSchemaObject(example, { ...options, description });
+    const schema2 = resolveSchemaObject(example, { allowExample: false });
+    schema2.items = toExampleSchema(example[0], description, options);
+    return schema2;
+  }
+  if (typeof description === "string")
+    return resolveSchemaObject(example, { ...options, description });
+  const schema = resolveSchemaObject(example, options);
+  schema.properties = Object.fromEntries(Object.entries(schema.properties).map(([p, item]) => [p, {
+    ...item,
+    ...typeof description === "object" ? { description: description?.[p] } : {}
+  }]));
+  return schema;
+}
+
+exports.createOpenApiRegister = createOpenApiRegister;
+exports.resolveSchemaObject = resolveSchemaObject;
+exports.toExampleSchema = toExampleSchema;

package/dist/index.d.cts

@@ -0,0 +1,105 @@
+import * as openapi_typescript from 'openapi-typescript';
+import { SchemaObject, ReferenceObject, PathItemObject, ResponseObject, MediaTypeObject, OperationObject, ParameterObject, RequestBodyObject, SecurityRequirementObject, OpenAPI3 } from 'openapi-typescript';
+
+type ReferenceRef<T extends OpenApiRegisterConfig> = T extends {
+    components: infer C;
+} ? {
+    [K in keyof C]: C[K] extends object ? `#/components/${K & string}/${keyof C[K] & string}` : never;
+}[keyof C] : string;
+type SchemaExtended<T extends string> = SchemaObject | ({
+    type: 'array';
+    prefixItems?: MaybeReference<SchemaExtended<T>, T>[];
+    items?: MaybeReference<SchemaExtended<T>, T> | MaybeReference<SchemaExtended<T>, T>[];
+    enum?: MaybeReference<SchemaExtended<T>, T>[];
+    description?: string;
+} | {
+    type: 'object' | ['object', 'null'];
+    properties?: {
+        [name: string]: MaybeReference<SchemaExtended<T>, T>;
+    };
+    allOf?: MaybeReference<SchemaExtended<T>, T>[];
+    anyOf?: MaybeReference<SchemaExtended<T>, T>[];
+    enum?: MaybeReference<SchemaExtended<T>, T>[];
+    description?: string;
+});
+type ReferenceExtended<T extends string> = Omit<ReferenceObject, '$ref'> & {
+    $ref: T;
+};
+type MaybeReference<T, R extends string = string> = T | ReferenceExtended<R>;
+type MaybeValueOrObject<ExampleT, ContentT> = ExampleT extends number | string | boolean ? ContentT : ExampleT extends (infer ArrayT)[] ? ContentT | MaybeValueOrObject<ArrayT, ContentT> : ExampleT extends Record<infer PropertyT, unknown> ? {
+    [key in PropertyT]?: ContentT;
+} | ContentT : ContentT;
+type PathOperations = Omit<PathItemObject, 'servers' | 'parameters' | `x-${string}`>;
+type PathOperationMethod = keyof PathOperations;
+type PathResponse<RefT extends string> = Omit<ResponseObject, 'content'> & {
+    content?: {
+        [contentType: string]: Omit<MediaTypeObject, 'schema'> & {
+            schema?: MaybeReference<SchemaExtended<RefT>, RefT>;
+        };
+    };
+};
+type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject, 'tags' | 'parameters' | 'requestBody' | 'responses' | 'security'> & {
+    tags?: T extends {
+        tags: infer Tags;
+    } ? Tags extends ({
+        name: infer Tag;
+    })[] ? Tag[] | string[] : string[] : string[];
+    parameters?: MaybeReference<ParameterObject & {
+        schema?: SchemaExtended<ReferenceRef<T>>;
+    }, ReferenceRef<T>>[];
+    requestBody?: MaybeReference<RequestBodyObject & {
+        content: {
+            [contentType: string]: MaybeReference<MediaTypeObject, ReferenceRef<T>>;
+        };
+    }, ReferenceRef<T>>;
+    responses?: {
+        [responseCode: string]: MaybeReference<PathResponse<ReferenceRef<T>>, ReferenceRef<T>>;
+    } & {
+        default?: MaybeReference<PathResponse<ReferenceRef<T>>, ReferenceRef<T>>;
+    };
+    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;
+    defineOperation: (operation: PathOperationItem<T>) => PathOperationItem<T>;
+    register: (route: string, routeOperation: MaybeReference<PathOperationItem<T>, ReferenceRef<T>>, method?: keyof PathOperations) => void;
+    merge: (config: Partial<OpenAPI3>) => Partial<OpenAPI3>;
+};
+
+type SchemaObjectOptions = SchemaObject & {
+    allowExample?: boolean;
+};
+declare function resolveSchemaObject(value: any, options?: SchemaObjectOptions): SchemaObject;
+type ExampleDescription<ExampleT> = MaybeValueOrObject<ExampleT, string>;
+declare function toExampleSchema<T = any>(example: T, description?: ExampleDescription<T>, options?: SchemaObject): {
+    [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?: (SchemaObject | openapi_typescript.ReferenceObject)[] | undefined;
+    allOf?: (SchemaObject | openapi_typescript.ReferenceObject)[] | undefined;
+    anyOf?: (SchemaObject | openapi_typescript.ReferenceObject)[] | undefined;
+    required?: string[] | undefined;
+};
+
+export { type MaybeReference, type MaybeValueOrObject, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type PathResponse, type ReferenceExtended, type ReferenceRef, type SchemaExtended, createOpenApiRegister, resolveSchemaObject, toExampleSchema };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as openapi_typescript from 'openapi-typescript';
-import { SchemaObject, ReferenceObject, PathItemObject, OperationObject, ParameterObject, RequestBodyObject, MediaTypeObject, SecurityRequirementObject, OpenAPI3 } from 'openapi-typescript';
+import { SchemaObject, ReferenceObject, PathItemObject, ResponseObject, MediaTypeObject, OperationObject, ParameterObject, RequestBodyObject, SecurityRequirementObject, OpenAPI3 } from 'openapi-typescript';
 
 type ReferenceRef<T extends OpenApiRegisterConfig> = T extends {
     components: infer C;
@@ -31,7 +31,14 @@ type MaybeValueOrObject<ExampleT, ContentT> = ExampleT extends number | string |
 } | ContentT : ContentT;
 type PathOperations = Omit<PathItemObject, 'servers' | 'parameters' | `x-${string}`>;
 type PathOperationMethod = keyof PathOperations;
-type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject, 'tags' | 'parameters' | 'requestBody' | 'security'> & {
+type PathResponse<RefT extends string> = Omit<ResponseObject, 'content'> & {
+    content?: {
+        [contentType: string]: Omit<MediaTypeObject, 'schema'> & {
+            schema?: MaybeReference<SchemaExtended<RefT>, RefT>;
+        };
+    };
+};
+type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject, 'tags' | 'parameters' | 'requestBody' | 'responses' | 'security'> & {
     tags?: T extends {
         tags: infer Tags;
     } ? Tags extends ({
@@ -45,6 +52,11 @@ type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject,
             [contentType: string]: MaybeReference<MediaTypeObject, ReferenceRef<T>>;
         };
     }, ReferenceRef<T>>;
+    responses?: {
+        [responseCode: string]: MaybeReference<PathResponse<ReferenceRef<T>>, ReferenceRef<T>>;
+    } & {
+        default?: MaybeReference<PathResponse<ReferenceRef<T>>, ReferenceRef<T>>;
+    };
     security?: T extends {
         components: infer C;
     } ? C extends {
@@ -57,10 +69,9 @@ type OpenApiRegisterConfig = Pick<Partial<OpenAPI3>, 'paths' | 'components' | 's
 
 declare function createOpenApiRegister<T extends OpenApiRegisterConfig = OpenApiRegisterConfig>(defaults: T): {
     configExtends: T;
+    defineOperation: (operation: PathOperationItem<T>) => PathOperationItem<T>;
     register: (route: string, routeOperation: MaybeReference<PathOperationItem<T>, ReferenceRef<T>>, method?: keyof PathOperations) => void;
-    merge: (config: Partial<OpenAPI3>) => {
-        info: openapi_typescript.InfoObject | undefined;
-    };
+    merge: (config: Partial<OpenAPI3>) => Partial<OpenAPI3>;
 };
 
 type SchemaObjectOptions = SchemaObject & {
@@ -91,4 +102,4 @@ declare function toExampleSchema<T = any>(example: T, description?: ExampleDescr
     required?: string[] | undefined;
 };
 
-export { type MaybeReference, type MaybeValueOrObject, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type ReferenceExtended, type ReferenceRef, type SchemaExtended, createOpenApiRegister, resolveSchemaObject, toExampleSchema };
+export { type MaybeReference, type MaybeValueOrObject, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type PathResponse, type ReferenceExtended, type ReferenceRef, type SchemaExtended, createOpenApiRegister, resolveSchemaObject, toExampleSchema };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as openapi_typescript from 'openapi-typescript';
-import { SchemaObject, ReferenceObject, PathItemObject, OperationObject, ParameterObject, RequestBodyObject, MediaTypeObject, SecurityRequirementObject, OpenAPI3 } from 'openapi-typescript';
+import { SchemaObject, ReferenceObject, PathItemObject, ResponseObject, MediaTypeObject, OperationObject, ParameterObject, RequestBodyObject, SecurityRequirementObject, OpenAPI3 } from 'openapi-typescript';
 
 type ReferenceRef<T extends OpenApiRegisterConfig> = T extends {
     components: infer C;
@@ -31,7 +31,14 @@ type MaybeValueOrObject<ExampleT, ContentT> = ExampleT extends number | string |
 } | ContentT : ContentT;
 type PathOperations = Omit<PathItemObject, 'servers' | 'parameters' | `x-${string}`>;
 type PathOperationMethod = keyof PathOperations;
-type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject, 'tags' | 'parameters' | 'requestBody' | 'security'> & {
+type PathResponse<RefT extends string> = Omit<ResponseObject, 'content'> & {
+    content?: {
+        [contentType: string]: Omit<MediaTypeObject, 'schema'> & {
+            schema?: MaybeReference<SchemaExtended<RefT>, RefT>;
+        };
+    };
+};
+type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject, 'tags' | 'parameters' | 'requestBody' | 'responses' | 'security'> & {
     tags?: T extends {
         tags: infer Tags;
     } ? Tags extends ({
@@ -45,6 +52,11 @@ type PathOperationItem<T extends OpenApiRegisterConfig> = Omit<OperationObject,
             [contentType: string]: MaybeReference<MediaTypeObject, ReferenceRef<T>>;
         };
     }, ReferenceRef<T>>;
+    responses?: {
+        [responseCode: string]: MaybeReference<PathResponse<ReferenceRef<T>>, ReferenceRef<T>>;
+    } & {
+        default?: MaybeReference<PathResponse<ReferenceRef<T>>, ReferenceRef<T>>;
+    };
     security?: T extends {
         components: infer C;
     } ? C extends {
@@ -57,10 +69,9 @@ type OpenApiRegisterConfig = Pick<Partial<OpenAPI3>, 'paths' | 'components' | 's
 
 declare function createOpenApiRegister<T extends OpenApiRegisterConfig = OpenApiRegisterConfig>(defaults: T): {
     configExtends: T;
+    defineOperation: (operation: PathOperationItem<T>) => PathOperationItem<T>;
     register: (route: string, routeOperation: MaybeReference<PathOperationItem<T>, ReferenceRef<T>>, method?: keyof PathOperations) => void;
-    merge: (config: Partial<OpenAPI3>) => {
-        info: openapi_typescript.InfoObject | undefined;
-    };
+    merge: (config: Partial<OpenAPI3>) => Partial<OpenAPI3>;
 };
 
 type SchemaObjectOptions = SchemaObject & {
@@ -91,4 +102,4 @@ declare function toExampleSchema<T = any>(example: T, description?: ExampleDescr
     required?: string[] | undefined;
 };
 
-export { type MaybeReference, type MaybeValueOrObject, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type ReferenceExtended, type ReferenceRef, type SchemaExtended, createOpenApiRegister, resolveSchemaObject, toExampleSchema };
+export { type MaybeReference, type MaybeValueOrObject, type OpenApiRegisterConfig, type PathOperationItem, type PathOperationMethod, type PathOperations, type PathResponse, type ReferenceExtended, type ReferenceRef, type SchemaExtended, createOpenApiRegister, resolveSchemaObject, toExampleSchema };

package/dist/index.mjs

@@ -2,6 +2,7 @@ import defu from 'defu';
 
 function createOpenApiRegister(defaults) {
   const { paths = {}, components = {}, security = [], servers = [], info, tags = [] } = defaults;
+  const defineOperation = (operation) => operation;
   function register(route, routeOperation, method = "get") {
     const _route = normalizeRoute(route);
     paths[_route] = defu(
@@ -31,6 +32,7 @@ function createOpenApiRegister(defaults) {
       info,
       tags
     },
+    defineOperation,
     register,
     merge
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@byyuurin/nitro-openapi",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "private": false,
   "license": "MIT",
   "homepage": "https://github.com/byyuurin/nitro-openapi",
@@ -12,7 +12,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -26,11 +27,11 @@
     "openapi-typescript": "^6.7.4"
   },
   "devDependencies": {
-    "@byyuurin/eslint-config": "^1.0.1",
-    "bumpp": "^9.3.0",
+    "@byyuurin/eslint-config": "^1.0.2",
+    "bumpp": "^9.3.1",
     "nitropack": "latest",
     "unbuild": "^2.0.0",
-    "vitest": "^1.3.0"
+    "vitest": "^1.3.1"
   },
   "resolutions": {
     "@byyuurin/nitro-openapi": "link:."