@elysiajs/openapi 1.4.10 → 1.4.12

package/dist/cjs/openapi.d.ts

@@ -10,7 +10,7 @@ export declare const capitalize: (word: string) => string;
  */
 export declare const getPossiblePath: (path: string) => string[];
 export declare const getLoosePath: (path: string) => string;
-export declare const unwrapSchema: (schema: InputSchema["body"], mapJsonSchema?: MapJsonSchema) => OpenAPIV3.SchemaObject | undefined;
+export declare const unwrapSchema: (schema: InputSchema["body"], mapJsonSchema?: MapJsonSchema, io?: "input" | "output") => OpenAPIV3.SchemaObject | undefined;
 export declare const enumToOpenApi: <T extends TAnySchema | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject | undefined>(_schema: T) => T;
 /**
  * Converts Elysia routes to OpenAPI 3.0.3 paths schema

package/dist/cjs/openapi.js

@@ -32,11 +32,7 @@ module.exports = __toCommonJS(openapi_exports);
 var import_elysia = require("elysia");
 
 // node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var TransformKind = Symbol.for("TypeBox.Transform");
-var ReadonlyKind = Symbol.for("TypeBox.Readonly");
-var OptionalKind = Symbol.for("TypeBox.Optional");
-var Hint = Symbol.for("TypeBox.Hint");
-var Kind = Symbol.for("TypeBox.Kind");
+var Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
 
 // src/openapi.ts
 var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
@@ -101,6 +97,212 @@ openapi({
 })`
 };
 var warned = {};
+var mergeObjectSchemas = (schemas) => {
+  if (schemas.length === 0)
+    return {
+      schema: void 0,
+      notObjects: []
+    };
+  if (schemas.length === 1)
+    return schemas[0].type === "object" ? {
+      schema: schemas[0],
+      notObjects: []
+    } : {
+      schema: void 0,
+      notObjects: schemas
+    };
+  let newSchema;
+  const notObjects = [];
+  let additionalPropertiesIsTrue = false;
+  let additionalPropertiesIsFalse = false;
+  for (const schema of schemas) {
+    if (!schema) continue;
+    if (schema.type !== "object") {
+      notObjects.push(schema);
+      continue;
+    }
+    if ("additionalProperties" in schema) {
+      if (schema.additionalProperties === true)
+        additionalPropertiesIsTrue = true;
+      else if (schema.additionalProperties === false)
+        additionalPropertiesIsFalse = true;
+    }
+    if (!newSchema) {
+      newSchema = schema;
+      continue;
+    }
+    newSchema = {
+      ...newSchema,
+      ...schema,
+      properties: {
+        ...newSchema.properties,
+        ...schema.properties
+      },
+      required: [
+        ...newSchema?.required ?? [],
+        ...schema.required ?? []
+      ]
+    };
+  }
+  if (newSchema) {
+    if (newSchema.required)
+      newSchema.required = [...new Set(newSchema.required)];
+    if (additionalPropertiesIsFalse) newSchema.additionalProperties = false;
+    else if (additionalPropertiesIsTrue)
+      newSchema.additionalProperties = true;
+  }
+  return {
+    schema: newSchema,
+    notObjects
+  };
+};
+var isTSchema = (value) => {
+  if (!value || typeof value !== "object") return false;
+  if (Kind in value) return true;
+  const keys = Object.keys(value);
+  if (keys.length > 0 && keys.every((k) => !isNaN(Number(k)))) {
+    return false;
+  }
+  return false;
+};
+var normalizeSchemaReference = (schema) => {
+  if (!schema) return void 0;
+  if (typeof schema !== "string") return schema;
+  return import_elysia.t.Ref(schema);
+};
+var mergeSchemaProperty = (existing, incoming, vendors) => {
+  if (!existing) return incoming;
+  if (!incoming) return existing;
+  const existingSchema = normalizeSchemaReference(existing);
+  let incomingSchema = normalizeSchemaReference(incoming);
+  if (!existingSchema) return incoming;
+  if (!incomingSchema) return existing;
+  if (!isTSchema(incomingSchema) && incomingSchema["~standard"])
+    incomingSchema = unwrapSchema(incomingSchema, vendors);
+  if (!incomingSchema) return existing;
+  const { schema: mergedSchema, notObjects } = mergeObjectSchemas([
+    existingSchema,
+    incomingSchema
+  ]);
+  if (notObjects.length > 0) {
+    if (mergedSchema) return import_elysia.t.Intersect([mergedSchema, ...notObjects]);
+    return notObjects.length === 1 ? notObjects[0] : import_elysia.t.Intersect(notObjects);
+  }
+  return mergedSchema;
+};
+var unwrapResponseSchema = (schema, vendors) => typeof schema === "string" ? normalizeSchemaReference(schema) : !schema ? void 0 : isTSchema(schema) ? schema : (
+  // @ts-ignore
+  schema["~standard"] ? unwrapSchema(schema, vendors, "output") : Object.fromEntries(
+    Object.entries(schema).map(([status, schema2]) => [
+      status,
+      typeof schema2 === "string" ? normalizeSchemaReference(schema2) : isTSchema(schema2) ? schema2 : unwrapSchema(schema2, vendors, "output")
+    ])
+  )
+);
+var mergeResponseSchema = (_existing, _incoming, vendors) => {
+  if (!_existing) return _incoming;
+  if (!_incoming) return _existing;
+  let existing = unwrapResponseSchema(_existing, vendors);
+  let incoming = unwrapResponseSchema(_incoming, vendors);
+  if (!existing && !incoming) return void 0;
+  if (incoming && !existing) return incoming;
+  if (existing && !incoming) return existing;
+  if (isTSchema(existing) || existing?.["~standard"])
+    existing = {
+      200: existing
+    };
+  if (isTSchema(incoming) || incoming?.["~standard"])
+    incoming = {
+      200: incoming
+    };
+  const schema = {
+    ...incoming
+  };
+  for (const status of Object.keys(existing ?? {})) {
+    const existingSchema = existing[status];
+    const incomingSchema = incoming[status];
+    if (existingSchema && incomingSchema)
+      schema[status] = mergeSchemaProperty(
+        existingSchema,
+        incomingSchema,
+        vendors
+      );
+    else if (existingSchema) schema[status] = existingSchema;
+    else if (incomingSchema) schema[status] = incomingSchema;
+  }
+  return schema;
+};
+var mergeStandaloneValidators = (hooks, vendors) => {
+  const merged = { ...hooks };
+  if (!hooks.standaloneValidator?.length) return merged;
+  for (const validator of hooks.standaloneValidator) {
+    if (validator.body)
+      merged.body = mergeSchemaProperty(
+        merged.body,
+        validator.body,
+        vendors
+      );
+    if (validator.headers)
+      merged.headers = mergeSchemaProperty(
+        merged.headers,
+        validator.headers,
+        vendors
+      );
+    if (validator.query)
+      merged.query = mergeSchemaProperty(
+        merged.query,
+        validator.query,
+        vendors
+      );
+    if (validator.params)
+      merged.params = mergeSchemaProperty(
+        merged.params,
+        validator.params,
+        vendors
+      );
+    if (validator.cookie)
+      merged.cookie = mergeSchemaProperty(
+        merged.cookie,
+        validator.cookie,
+        vendors
+      );
+    if (validator.response)
+      merged.response = mergeResponseSchema(
+        merged.response,
+        validator.response,
+        vendors
+      );
+  }
+  if (typeof merged.body === "string")
+    merged.body = normalizeSchemaReference(merged.body);
+  if (typeof merged.headers === "string")
+    merged.headers = normalizeSchemaReference(merged.headers);
+  if (typeof merged.query === "string")
+    merged.query = normalizeSchemaReference(merged.query);
+  if (typeof merged.params === "string")
+    merged.params = normalizeSchemaReference(merged.params);
+  if (typeof merged.cookie === "string")
+    merged.cookie = normalizeSchemaReference(merged.cookie);
+  if (merged.response && typeof merged.response !== "string") {
+    const response = merged.response;
+    if ("type" in response || "$ref" in response) {
+      if (typeof response === "string")
+        merged.response = normalizeSchemaReference(response);
+    } else {
+      for (const [status, schema] of Object.entries(response))
+        if (typeof schema === "string")
+          response[status] = normalizeSchemaReference(schema);
+    }
+  }
+  return merged;
+};
+var flattenRoutes = (routes, vendors) => routes.map((route) => {
+  if (!route.hooks?.standaloneValidator?.length) return route;
+  return {
+    ...route,
+    hooks: mergeStandaloneValidators(route.hooks, vendors)
+  };
+});
 var unwrapReference = (schema, definitions) => {
   const ref = schema?.$ref;
   if (!ref) return schema;
@@ -108,13 +310,15 @@ var unwrapReference = (schema, definitions) => {
   if (ref && definitions[name]) schema = definitions[name];
   return enumToOpenApi(schema);
 };
-var unwrapSchema = (schema, mapJsonSchema) => {
+var unwrapSchema = (schema, mapJsonSchema, io = "input") => {
   if (!schema) return;
   if (typeof schema === "string") schema = toRef(schema);
   if (Kind in schema) return enumToOpenApi(schema);
   if (Kind in schema || !schema?.["~standard"]) return;
   const vendor = schema["~standard"].vendor;
   try {
+    if (schema["~standard"]?.jsonSchema?.[io])
+      return schema["~standard"]?.jsonSchema?.[io]?.();
     if (mapJsonSchema?.[vendor] && typeof mapJsonSchema[vendor] === "function")
       return enumToOpenApi(mapJsonSchema[vendor](schema));
     switch (vendor) {
@@ -209,7 +413,6 @@ function toOpenAPISchema(app, exclude, references, vendors) {
   const excludePaths = Array.isArray(exclude?.paths) ? exclude.paths : typeof exclude?.paths !== "undefined" ? [exclude.paths] : [];
   const paths = /* @__PURE__ */ Object.create(null);
   const definitions = app.getGlobalDefinitions?.().type;
-  const routes = app.getGlobalRoutes();
   if (references) {
     if (!Array.isArray(references)) references = [references];
     for (let i = 0; i < references.length; i++) {
@@ -217,6 +420,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       if (typeof reference === "function") references[i] = reference();
     }
   }
+  const routes = flattenRoutes(app.getGlobalRoutes(), vendors);
   for (const route of routes) {
     if (route.hooks?.detail?.hide) continue;
     const method = route.method.toLowerCase();
@@ -406,7 +610,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
       if (typeof hooks.response === "object" && // TypeBox
       !hooks.response.type && !hooks.response.$ref && !hooks.response["~standard"]) {
         for (let [status, schema] of Object.entries(hooks.response)) {
-          const response = unwrapSchema(schema, vendors);
+          const response = unwrapSchema(schema, vendors, "output");
           if (!response) continue;
           const { type, description, $ref, ..._options } = unwrapReference(response, definitions);
           operation.responses[status] = {
@@ -423,7 +627,7 @@ function toOpenAPISchema(app, exclude, references, vendors) {
           };
         }
       } else {
-        const response = unwrapSchema(hooks.response, vendors);
+        const response = unwrapSchema(hooks.response, vendors, "output");
         if (response) {
           const {
             type: _type,

package/dist/cjs/scalar/index.js

@@ -143,7 +143,7 @@ var elysiaCSS = `.light-mode {
   background-image: var(--stripes), var(--rainbow);
   filter: opacity(4%) saturate(200%);
 }`;
-var ScalarRender = (info, config) => `<!doctype html>
+var ScalarRender = (info, config, embedSpec) => `<!doctype html>
 <html>
   <head>
     <title>${info.title}</title>
@@ -171,7 +171,14 @@ var ScalarRender = (info, config) => `<!doctype html>
   <body>
     <script
       id="api-reference"
-      data-url="${config.url}"
+      data-configuration='${JSON.stringify(
+  Object.assign(
+    config,
+    {
+      content: embedSpec
+    }
+  )
+)}'
     >
     </script>
     <script src="${config.cdn}" crossorigin></script>

package/dist/cjs/types.d.ts

@@ -74,6 +74,14 @@ export interface ElysiaOpenAPIConfig<Enabled extends boolean = true, Path extend
      * Additional reference for each endpoint
      */
     references?: AdditionalReferences;
+    /**
+     * Embed OpenAPI schema to provider body if possible
+     *
+     * This is highly discouraged, unless you really have to inline OpenAPI schema
+     *
+     * @default false
+     */
+    embedSpec?: boolean;
     /**
      * Mapping function from Standard schema to OpenAPI schema
      *