@shipworthy/openapi-parser 0.0.2 → 1.0.0

package/dist/schemas/3.1/media-type.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Record as Rec, Schema } from "effect";
 import { OpenApiEncoding } from "./encoding.js";
 import { OpenApiExample } from "./example.js";
 import { openApiObject } from "./object.js";
@@ -9,6 +9,6 @@ export const OpenApiMediaType = openApiObject({
     example: Schema.optionalKey(Schema.Unknown),
     examples: Schema.optionalKey(Schema.Record(Schema.String, withReference(OpenApiExample))),
     encoding: Schema.optionalKey(Schema.Record(Schema.String, OpenApiEncoding)),
-}).check(Schema.makeFilter((value) => Object.hasOwn(value, "example") && value.examples !== undefined
+}).check(Schema.makeFilter((value) => Rec.has(value, "example") && value.examples !== undefined
     ? "Media type example and examples are mutually exclusive"
     : undefined));

package/dist/schemas/3.1/object.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Array as Arr, Formatter, Option, pipe, Record as Rec, Schema, String as Str, } from "effect";
 /** Preserve extensions and unrecognized fields while validating every declared field. */
 export function openApiObject(fields) {
     return Schema.StructWithRest(Schema.Struct(fields), [
@@ -10,8 +10,5 @@ export function openApiMap(key, value) {
     const isKey = Schema.is(key);
     return Schema.StructWithRest(Schema.Record(key, value), [
         Schema.Record(Schema.String, Schema.Unknown),
-    ]).check(Schema.makeFilter((entries) => {
-        const invalid = Object.keys(entries).find((name) => !name.startsWith("x-") && !isKey(name));
-        return invalid === undefined ? undefined : `Unexpected key ${JSON.stringify(invalid)}`;
-    }));
+    ]).check(Schema.makeFilter((entries) => pipe(Rec.keys(entries), Arr.findFirst((name) => !Str.startsWith("x-")(name) && !isKey(name)), Option.map((invalid) => `Unexpected key ${Formatter.formatJson(invalid)}`), Option.getOrUndefined)));
 }

package/dist/schemas/3.1/parameter.js

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Record as Rec, Schema } from "effect";
 import { OpenApiHeader } from "./header.js";
 import { openApiObject } from "./object.js";
 export const OpenApiParameter = openApiObject({
@@ -23,10 +23,10 @@ export const OpenApiParameter = openApiObject({
     if ((value.schema === undefined) === (value.content === undefined)) {
         return "A parameter must have exactly one of schema or content";
     }
-    if (value.content !== undefined && Object.keys(value.content).length !== 1) {
+    if (value.content !== undefined && Rec.size(value.content) !== 1) {
         return "Parameter content must contain exactly one media type";
     }
-    if (Object.hasOwn(value, "example") && value.examples !== undefined) {
+    if (Rec.has(value, "example") && value.examples !== undefined) {
         return "Parameter example and examples are mutually exclusive";
     }
     return undefined;

package/dist/schemas/3.1/responses.js

@@ -1,7 +1,7 @@
-import { Schema } from "effect";
+import { Array as Arr, Record as Rec, Schema, String as Str } from "effect";
 import { openApiMap } from "./object.js";
 import { withReference } from "./reference.js";
 import { OpenApiResponse } from "./response.js";
-export const OpenApiResponses = openApiMap(Schema.String.check(Schema.isPattern(/^(?:default|[1-5](?:\d{2}|XX))$/)), withReference(OpenApiResponse)).check(Schema.makeFilter((value) => Object.keys(value).some((key) => !key.startsWith("x-"))
+export const OpenApiResponses = openApiMap(Schema.String.check(Schema.isPattern(/^(?:default|[1-5](?:\d{2}|XX))$/)), withReference(OpenApiResponse)).check(Schema.makeFilter((value) => Arr.some(Rec.keys(value), (key) => !Str.startsWith("x-")(key))
     ? undefined
     : "Responses must contain at least one response"));

package/dist/upgraders/3.0-to-3.1.js

@@ -1,4 +1,4 @@
-import { JsonSchema, Predicate } from "effect";
+import { Array as Arr, JsonSchema, Predicate, Record as Rec, String as Str } from "effect";
 import { OpenApiHttpMethod } from "../schemas/3.1/http-method.js";
 function asRecord(value) {
     return Predicate.isObject(value) ? value : undefined;
@@ -22,11 +22,11 @@ const ARRAY_KEYS = ["allOf", "anyOf", "oneOf", "prefixItems"];
 const MAP_KEYS = ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"];
 export function isOpenApi3(document) {
     const record = asRecord(document);
-    return typeof record?.openapi === "string" && record.openapi.startsWith("3.");
+    return typeof record?.openapi === "string" && Str.startsWith("3.")(record.openapi);
 }
 export function isOpenApi3_0(document) {
     const record = asRecord(document);
-    return typeof record?.openapi === "string" && record.openapi.startsWith("3.0");
+    return typeof record?.openapi === "string" && Str.startsWith("3.0")(record.openapi);
 }
 export function upgradeOpenApi3_0(document) {
     if (!isOpenApi3_0(document))
@@ -48,18 +48,18 @@ export function schemaSlots(document, includeComponentSchemas = true) {
         collectHeaderMap(components.headers, slots);
         const pathItems = asRecord(components.pathItems);
         if (pathItems) {
-            for (const value of Object.values(pathItems))
+            for (const value of Rec.values(pathItems))
                 collectPathItem(value, slots);
         }
     }
     const paths = asRecord(document.paths);
     if (paths) {
-        for (const value of Object.values(paths))
+        for (const value of Rec.values(paths))
             collectPathItem(value, slots);
     }
     const webhooks = asRecord(document.webhooks);
     if (webhooks) {
-        for (const value of Object.values(webhooks))
+        for (const value of Rec.values(webhooks))
             collectPathItem(value, slots);
     }
     return slots;
@@ -73,35 +73,35 @@ function collectSchemaMap(value, slots) {
     const map = asRecord(value);
     if (!map)
         return;
-    for (const key of Object.keys(map))
+    for (const key of Rec.keys(map))
         slots.push({ parent: map, key });
 }
 function collectParameterMap(value, slots) {
     const map = asRecord(value);
     if (!map)
         return;
-    for (const parameter of Object.values(map))
+    for (const parameter of Rec.values(map))
         collectParameter(parameter, slots);
 }
 function collectResponseMap(value, slots) {
     const map = asRecord(value);
     if (!map)
         return;
-    for (const response of Object.values(map))
+    for (const response of Rec.values(map))
         collectResponse(response, slots);
 }
 function collectRequestBodyMap(value, slots) {
     const map = asRecord(value);
     if (!map)
         return;
-    for (const body of Object.values(map))
+    for (const body of Rec.values(map))
         collectRequestBody(body, slots);
 }
 function collectHeaderMap(value, slots) {
     const map = asRecord(value);
     if (!map)
         return;
-    for (const header of Object.values(map))
+    for (const header of Rec.values(map))
         collectHeader(header, slots);
 }
 function collectPathItem(value, slots) {
@@ -109,7 +109,7 @@ function collectPathItem(value, slots) {
     if (!record || typeof record.$ref === "string")
         return;
     collectParameterList(record.parameters, slots);
-    for (const [key, child] of Object.entries(record)) {
+    for (const [key, child] of Rec.toEntries(record)) {
         if (METHODS.has(key))
             collectOperation(child, slots);
     }
@@ -122,22 +122,22 @@ function collectOperation(value, slots) {
     collectRequestBody(record.requestBody, slots);
     const responses = asRecord(record.responses);
     if (responses) {
-        for (const response of Object.values(responses))
+        for (const response of Rec.values(responses))
             collectResponse(response, slots);
     }
     const callbacks = asRecord(record.callbacks);
     if (callbacks) {
-        for (const callback of Object.values(callbacks)) {
+        for (const callback of Rec.values(callbacks)) {
             const paths = asRecord(callback);
             if (!paths || typeof paths.$ref === "string")
                 continue;
-            for (const pathItem of Object.values(paths))
+            for (const pathItem of Rec.values(paths))
                 collectPathItem(pathItem, slots);
         }
     }
 }
 function collectParameterList(value, slots) {
-    if (!Array.isArray(value))
+    if (!Arr.isArray(value))
         return;
     for (const parameter of value)
         collectParameter(parameter, slots);
@@ -175,7 +175,7 @@ function collectContent(value, slots) {
     const content = asRecord(value);
     if (!content)
         return;
-    for (const media of Object.values(content)) {
+    for (const media of Rec.values(content)) {
         const mediaRecord = asRecord(media);
         if (mediaRecord && "schema" in mediaRecord)
             slots.push({ parent: mediaRecord, key: "schema" });
@@ -188,25 +188,26 @@ function upgradeSchema(value) {
     for (const key of SINGLE_KEYS) {
         if (!(key in record))
             continue;
-        if (key === "items" && Array.isArray(record.items)) {
-            record.items = record.items.map((item) => upgradeSchema(item));
+        if (key === "items" && Arr.isArray(record.items)) {
+            record.items = Arr.map(record.items, (item) => upgradeSchema(item));
         }
         else {
             record[key] = upgradeSchema(record[key]);
         }
     }
     for (const key of ARRAY_KEYS) {
-        if (Array.isArray(record[key]))
-            record[key] = record[key].map((item) => upgradeSchema(item));
+        const items = record[key];
+        if (Arr.isArray(items))
+            record[key] = Arr.map(items, (item) => upgradeSchema(item));
     }
     for (const key of MAP_KEYS) {
         const map = asRecord(record[key]);
         if (!map)
             continue;
-        for (const child of Object.keys(map))
+        for (const child of Rec.keys(map))
             map[child] = upgradeSchema(map[child]);
     }
-    if (Array.isArray(record.items)) {
+    if (Arr.isArray(record.items)) {
         record.prefixItems = record.items;
         if ("additionalItems" in record) {
             record.items = record.additionalItems;
@@ -216,7 +217,7 @@ function upgradeSchema(value) {
             delete record.items;
         }
     }
-    if (typeof record.$ref === "string" && Object.keys(record).some((key) => key !== "$ref")) {
+    if (typeof record.$ref === "string" && Arr.some(Rec.keys(record), (key) => key !== "$ref")) {
         const nullable = record.nullable === true;
         const readOnly = record.readOnly === true;
         const writeOnly = record.writeOnly === true;
@@ -227,7 +228,9 @@ function upgradeSchema(value) {
         if (writeOnly)
             delete siblings.writeOnly;
         // OpenAPI 3.0 ignores the siblings of a $ref; 3.1 applies them, so they move into allOf
-        const target = Object.keys(siblings).length > 0 ? { allOf: [{ $ref }, siblings] } : { $ref };
+        const target = !Rec.isEmptyRecord(siblings)
+            ? { allOf: [{ $ref }, siblings] }
+            : { $ref };
         const lifted = nullable ? orNull(target) : target;
         if (readOnly)
             lifted.readOnly = true;
@@ -255,13 +258,13 @@ const ANNOTATION_KEYS = new Set([
 function orNull(schema) {
     const outer = {};
     const inner = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (ANNOTATION_KEYS.has(key) || key.startsWith("x-"))
+    for (const [key, value] of Rec.toEntries(schema)) {
+        if (ANNOTATION_KEYS.has(key) || Str.startsWith("x-")(key))
             outer[key] = value;
         else
             inner[key] = value;
     }
-    return Object.keys(inner).length === 0 ? schema : { ...outer, anyOf: [inner, { type: "null" }] };
+    return Rec.isEmptyRecord(inner) ? schema : { ...outer, anyOf: [inner, { type: "null" }] };
 }
 function applyOpenApi30Keywords(schema) {
     const nullable = schema.nullable === true;
@@ -289,8 +292,8 @@ function applyOpenApi30Keywords(schema) {
     }
     if ("example" in schema) {
         const converted = JsonSchema.fromSchemaOpenApi3_0({ example: schema.example }).schema;
-        const existing = Array.isArray(schema.examples) ? schema.examples : [];
-        const convertedExamples = Array.isArray(converted.examples) ? converted.examples : [];
+        const existing = Arr.isArray(schema.examples) ? schema.examples : [];
+        const convertedExamples = Arr.isArray(converted.examples) ? converted.examples : [];
         schema.examples = [...convertedExamples, ...existing];
         delete schema.example;
     }
@@ -302,7 +305,7 @@ function applyOpenApi30Keywords(schema) {
     if (typeof schema.type === "string" && !composed) {
         const converted = JsonSchema.fromSchemaOpenApi3_0({ type: schema.type, nullable: true }).schema;
         schema.type = converted.type;
-        if (Array.isArray(schema.enum) && !schema.enum.includes(null))
+        if (Arr.isArray(schema.enum) && !schema.enum.includes(null))
             schema.enum = [...schema.enum, null];
         return schema;
     }

package/dist/url.d.ts

@@ -24,6 +24,6 @@ export declare const resolveUrlSafety: (href: string) => Effect.Effect<{
     addresses?: undefined;
 } | {
     unsafe: boolean;
-    addresses: import("dns").LookupAddress[];
+    addresses: import("node:dns").LookupAddress[];
 }, ResolverFailure, never>;
 export declare function isUnsafeHostname(hostname: string): boolean;

package/dist/url.js

@@ -1,6 +1,6 @@
 import * as NodePath from "@effect/platform-node/NodePath";
 import { fileURLToPath } from "node:url";
-import { Effect, Path } from "effect";
+import { Array as Arr, Effect, Option, Path, pipe, String as Str } from "effect";
 import { ResolverFailure, nodeErrorCode } from "./errors.js";
 const unsafeDomainSuffixes = [
     ".localhost",
@@ -12,14 +12,10 @@ const unsafeDomainSuffixes = [
     ".lan",
 ];
 export function stripHash(value) {
-    const index = value.indexOf("#");
-    return index === -1 ? value : value.slice(0, index);
+    return pipe(value, Str.indexOf("#"), Option.match({ onNone: () => value, onSome: (index) => Str.slice(0, index)(value) }));
 }
 export function getHash(value) {
-    const index = value.indexOf("#");
-    if (index === -1)
-        return "#";
-    return value.slice(index) || "#";
+    return pipe(value, Str.indexOf("#"), Option.match({ onNone: () => "#", onSome: (index) => Str.slice(index)(value) || "#" }));
 }
 export function isHttp(value) {
     return /^https?:\/\//i.test(value);
@@ -27,7 +23,7 @@ export function isHttp(value) {
 export function isFileSystemPath(value) {
     if (!value)
         return false;
-    if (value.startsWith("file:"))
+    if (Str.startsWith("file:")(value))
         return true;
     return !/^[a-z][a-z0-9+.-]*:/i.test(value);
 }
@@ -60,29 +56,31 @@ export function resolveAgainst(from, to) {
 }
 export function toFileSystemPath(ref) {
     const withoutHash = stripHash(ref);
-    if (withoutHash.startsWith("file:"))
+    if (Str.startsWith("file:")(withoutHash))
         return fileURLToPath(withoutHash);
     return withoutHash;
 }
 export function extensionOf(ref) {
-    const pathname = stripHash(ref).split("?")[0] ?? "";
-    const base = pathname.slice(Math.max(pathname.lastIndexOf("/"), pathname.lastIndexOf("\\")) + 1);
-    const dot = base.lastIndexOf(".");
-    return dot >= 0 ? base.slice(dot).toLowerCase() : "";
+    const pathname = pipe(stripHash(ref), Str.split("?"), Arr.headNonEmpty);
+    const base = pipe(pathname, Str.split(/[/\\]/), Arr.lastNonEmpty);
+    return pipe(base, Str.lastIndexOf("."), Option.match({
+        onNone: () => "",
+        onSome: (dot) => pipe(base, Str.slice(dot), Str.toLowerCase),
+    }));
 }
 export function isUnsafeUrl(value) {
-    const normalized = value.trim().toLowerCase();
+    const normalized = pipe(value, Str.trim, Str.toLowerCase);
     if (!normalized)
         return true;
-    if (normalized.startsWith("javascript:") ||
-        normalized.startsWith("vbscript:") ||
-        normalized.startsWith("data:")) {
+    if (Str.startsWith("javascript:")(normalized) ||
+        Str.startsWith("vbscript:")(normalized) ||
+        Str.startsWith("data:")(normalized)) {
         return true;
     }
-    if (normalized.startsWith("file:"))
+    if (Str.startsWith("file:")(normalized))
         return true;
     try {
-        const url = new URL(normalized.startsWith("//") ? `http:${normalized}` : normalized);
+        const url = new URL(Str.startsWith("//")(normalized) ? `http:${normalized}` : normalized);
         if (isUnsafeHostname(url.hostname))
             return true;
         if (url.port && isInternalPort(Number(url.port)))
@@ -97,14 +95,14 @@ export function isAllowedOrigin(href, allowedOrigins) {
     const origin = httpOrigin(href);
     if (!origin || !allowedOrigins?.length)
         return false;
-    return allowedOrigins.some((allowed) => httpOrigin(allowed) === origin);
+    return Arr.some(allowedOrigins, (allowed) => httpOrigin(allowed) === origin);
 }
 export const resolveUrlSafety = Effect.fnUntraced(function* (href) {
     if (isUnsafeUrl(href))
         return { unsafe: true };
     if (typeof process === "undefined" || !process.versions?.node)
         return { unsafe: false };
-    const parsed = URL.parse(href.startsWith("//") ? `http:${href}` : href);
+    const parsed = URL.parse(Str.startsWith("//")(href) ? `http:${href}` : href);
     if (parsed === null)
         return { unsafe: true };
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
@@ -123,7 +121,7 @@ export const resolveUrlSafety = Effect.fnUntraced(function* (href) {
         try: () => dns.lookup(normalizeHostname(parsed.hostname), { all: true, verbatim: true }),
         catch: onError,
     });
-    if (addresses.length === 0 || addresses.some(({ address }) => isUnsafeHostname(address))) {
+    if (addresses.length === 0 || Arr.some(addresses, ({ address }) => isUnsafeHostname(address))) {
         return { unsafe: true };
     }
     return { unsafe: false, addresses };
@@ -133,7 +131,7 @@ export function isUnsafeHostname(hostname) {
     if (!normalized)
         return true;
     if (normalized === "localhost" ||
-        unsafeDomainSuffixes.some((suffix) => normalized.endsWith(suffix)))
+        Arr.some(unsafeDomainSuffixes, (suffix) => Str.endsWith(suffix)(normalized)))
         return true;
     const ipv4 = parseIPv4Address(normalized);
     if (ipv4)
@@ -148,19 +146,19 @@ function ioCode(cause) {
     return ioErrorCode ? { ioErrorCode } : undefined;
 }
 function normalizeHostname(hostname) {
-    let normalized = hostname.trim().toLowerCase();
-    if (normalized.startsWith("[") && normalized.endsWith("]"))
-        normalized = normalized.slice(1, -1);
-    while (normalized.endsWith("."))
-        normalized = normalized.slice(0, -1);
+    let normalized = pipe(hostname, Str.trim, Str.toLowerCase);
+    if (Str.startsWith("[")(normalized) && Str.endsWith("]")(normalized))
+        normalized = Str.slice(1, -1)(normalized);
+    while (Str.endsWith(".")(normalized))
+        normalized = Str.slice(0, -1)(normalized);
     return normalized;
 }
 function parseIPv4Address(ip) {
-    const parts = ip.split(".");
+    const parts = Str.split(ip, ".");
     if (parts.length !== 4)
         return undefined;
-    const octets = parts.map((part) => (/^\d+$/.test(part) ? Number(part) : Number.NaN));
-    if (octets.some((octet) => !Number.isInteger(octet) || octet < 0 || octet > 255))
+    const octets = Arr.map(parts, (part) => (/^\d+$/.test(part) ? Number(part) : Number.NaN));
+    if (Arr.some(octets, (octet) => !Number.isInteger(octet) || octet < 0 || octet > 255))
         return undefined;
     return octets;
 }
@@ -184,23 +182,24 @@ function isUnsafeIPv4Address(octets) {
         (a === 255 && b === 255 && c === 255 && d === 255));
 }
 function parseIPv6Address(ip) {
-    if (!ip.includes(":"))
+    const separator = Str.lastIndexOf(":")(ip);
+    if (Option.isNone(separator))
         return undefined;
     let normalized = ip;
-    const lastSeparator = normalized.lastIndexOf(":");
-    const possibleIPv4 = normalized.slice(lastSeparator + 1);
-    if (possibleIPv4.includes(".")) {
+    const lastSeparator = separator.value;
+    const possibleIPv4 = Str.slice(lastSeparator + 1)(normalized);
+    if (Str.includes(".")(possibleIPv4)) {
         const ipv4 = parseIPv4Address(possibleIPv4);
         if (!ipv4)
             return undefined;
         const firstGroup = ipv4[0] * 256 + ipv4[1];
         const secondGroup = ipv4[2] * 256 + ipv4[3];
-        normalized = `${normalized.slice(0, lastSeparator + 1)}${firstGroup.toString(16)}:${secondGroup.toString(16)}`;
+        normalized = `${Str.slice(0, lastSeparator + 1)(normalized)}${firstGroup.toString(16)}:${secondGroup.toString(16)}`;
     }
-    const halves = normalized.split("::");
+    const halves = Str.split(normalized, "::");
     if (halves.length > 2)
         return undefined;
-    const head = parseIPv6Groups(halves[0] ?? "");
+    const head = parseIPv6Groups(Arr.headNonEmpty(halves));
     const tail = halves.length === 2 ? parseIPv6Groups(halves[1] ?? "") : [];
     if (!head || !tail)
         return undefined;
@@ -214,18 +213,16 @@ function parseIPv6Address(ip) {
 function parseIPv6Groups(groups) {
     if (!groups)
         return [];
-    const parsed = groups
-        .split(":")
-        .map((group) => (/^[\da-f]{1,4}$/i.test(group) ? Number.parseInt(group, 16) : Number.NaN));
-    if (parsed.some((group) => !Number.isInteger(group) || group < 0 || group > 0xffff))
+    const parsed = pipe(groups, Str.split(":"), Arr.map((group) => (/^[\da-f]{1,4}$/i.test(group) ? Number.parseInt(group, 16) : Number.NaN)));
+    if (Arr.some(parsed, (group) => !Number.isInteger(group) || group < 0 || group > 0xffff))
         return undefined;
     return parsed;
 }
 function isUnsafeIPv6Address(groups) {
     if (groups.length !== 8)
         return false;
-    const unspecified = groups.every((group) => group === 0);
-    const loopback = groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1;
+    const unspecified = Arr.every(groups, (group) => group === 0);
+    const loopback = Arr.every(groups.slice(0, 7), (group) => group === 0) && groups[7] === 1;
     const uniqueLocal = (groups[0] & 0xfe00) === 0xfc00;
     const linkLocal = (groups[0] & 0xffc0) === 0xfe80;
     const multicast = (groups[0] & 0xff00) === 0xff00;
@@ -235,7 +232,7 @@ function isUnsafeIPv6Address(groups) {
     return mapped ? isUnsafeIPv4Address(mapped) : false;
 }
 function mappedIPv4(groups) {
-    const firstFive = groups.slice(0, 5).every((group) => group === 0);
+    const firstFive = Arr.every(groups.slice(0, 5), (group) => group === 0);
     const firstSix = firstFive && groups[5] === 0;
     const v4Mapped = firstFive && groups[5] === 0xffff;
     if (!firstSix && !v4Mapped)