@shipworthy/openapi-parser 0.0.1 → 1.0.0

package/dist/parsers.js

@@ -1,4 +1,4 @@
-import { Effect, Predicate } from "effect";
+import { Effect, Predicate, Schema, String as Str } from "effect";
 import { ParseError, ParserFailure } from "./errors.js";
 import { promisePlugin } from "./plugins.js";
 import { extensionOf } from "./url.js";
@@ -7,19 +7,18 @@ function decodeData(data) {
     if (data === undefined)
         return "";
     const text = typeof data === "string" ? data : new TextDecoder().decode(data);
-    return text.replace(/^\uFEFF/, "");
+    return Str.replace(/^\uFEFF/, "")(text);
 }
+const decodeJsonText = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
 function parseJsonText(text) {
-    if (text.trim().length === 0)
-        return null;
-    return JSON.parse(text);
+    return Str.isEmpty(Str.trim(text)) ? Effect.succeed(null) : decodeJsonText(text);
 }
 export const parseText = Effect.fnUntraced(function* (source) {
     const text = decodeData(source);
-    const first = text.trimStart()[0];
+    const first = Str.trimStart(text)[0];
     const yaml = () => Effect.try({ try: () => parseYamlDocument(text), catch: parseFailure });
     if (first === "{" || first === "[") {
-        return yield* Effect.try({ try: () => parseJsonText(text), catch: parseFailure }).pipe(Effect.catch(yaml));
+        return yield* parseJsonText(text).pipe(Effect.catch(yaml));
     }
     return yield* yaml();
 });
@@ -45,20 +44,10 @@ function jsonParser() {
         order: 100,
         can: (file) => extensionOf(file.url) === ".json" || extensionOf(file.url) === "",
         run(file) {
-            return Effect.try({
-                try: () => parseJson(file),
-                catch: (cause) => new ParserFailure({
-                    message: cause instanceof Error ? cause.message : "Parser Error",
-                    source: file.url,
-                    cause,
-                }),
-            });
+            return parseJsonText(decodeData(file.data)).pipe(Effect.mapError((cause) => new ParserFailure({ message: cause.message, source: file.url, cause })));
         },
     };
 }
-function parseJson(file) {
-    return parseJsonText(decodeData(file.data));
-}
 function yamlParser() {
     return {
         order: 200,

package/dist/pipeline.js

@@ -1,4 +1,4 @@
-import { JsonPointer, JsonSchema, Predicate } from "effect";
+import { Array as Arr, Formatter, JsonPointer, JsonSchema, Predicate, Record as Rec, String as Str, } from "effect";
 import { getAt, joinPointer } from "./pointer.js";
 import { componentSchemas, schemaSlots } from "./upgraders/3.0-to-3.1.js";
 import { bundleFailure, circularAliasFailure, invalidPointerFailure, missingPointerFailure, } from "./errors.js";
@@ -37,7 +37,7 @@ export function runSchemaPipeline(document, mode, hooks) {
     }
     const others = schemaSlots(document, false);
     const slotSchemas = [];
-    const booleanSlots = others.map((slot) => {
+    const booleanSlots = Arr.map(others, (slot) => {
         const value = slot.parent[slot.key];
         return typeof value === "boolean" ? value : undefined;
     });
@@ -48,10 +48,10 @@ export function runSchemaPipeline(document, mode, hooks) {
         slotSchemas.push(normalized.schema);
     }
     const recursive = recursiveNames(definitions);
-    const rootDefs = new Set(Object.keys(asRecord(document.$defs) ?? {}));
+    const rootDefs = new Set(Rec.keys(asRecord(document.$defs) ?? {}));
     const aliases = new Map();
     const resolving = new Set();
-    for (const name of Object.keys(definitions)) {
+    for (const name of Rec.keys(definitions)) {
         definitions[name] = resolveValue(definitions[name], definitions, rootDefs, recursive, aliases, resolving, mode, hooks, `#/$defs/${name}`);
     }
     for (let index = 0; index < slotSchemas.length; index++) {
@@ -61,9 +61,9 @@ export function runSchemaPipeline(document, mode, hooks) {
             slot.parent[slot.key] = slotSchemas[index];
     }
     const parked = [];
-    for (const [name, schema] of Object.entries(definitions))
+    for (const [name, schema] of Rec.toEntries(definitions))
         park(schema, "definition", name, [], parked);
-    slotSchemas.forEach((schema, index) => park(schema, "schema", String(index), [], parked));
+    Arr.forEach(slotSchemas, (schema, index) => park(schema, "schema", String(index), [], parked));
     const schemas = (slotSchemas.length > 0 ? slotSchemas : [{}]);
     const converted = JsonSchema.toMultiDocumentOpenApi3_1({
         dialect: "draft-2020-12",
@@ -79,7 +79,7 @@ export function runSchemaPipeline(document, mode, hooks) {
         if (value !== undefined)
             slot.parent[slot.key] = value;
     }
-    others.forEach((slot, index) => {
+    Arr.forEach(others, (slot, index) => {
         slot.parent[slot.key] = booleanSlots[index] ?? converted.schemas[index];
     });
     rewriteLeftoverDefinitionRefs(document);
@@ -94,26 +94,26 @@ function normalizeSchema(value) {
     const record = asRecord(value);
     if (!record)
         throw bundleFailure("A schema position must contain an object or a boolean");
-    const normalized = JsonSchema.fromSchemaOpenApi3_1(liftSiblings(record));
+    const normalized = JsonSchema.fromSchemaOpenApi3_1(record);
     // A schema $id is its own resource, so its $defs join the shared pool.
     // Nested $defs on a schema without $id stay on that schema.
     if (typeof record.$id === "string")
         return normalized;
     const extracted = asRecord(normalized.definitions);
-    if (!extracted || Object.keys(extracted).length === 0)
+    if (!extracted || Rec.isEmptyRecord(extracted))
         return normalized;
     const schema = asRecord(normalized.schema) ?? {};
     schema.$defs = { ...asRecord(schema.$defs), ...extracted };
     return { dialect: normalized.dialect, schema, definitions: {} };
 }
 function mergeDefinitions(pool, extra, owner, order) {
-    for (const [name, schema] of Object.entries(extra)) {
-        if (!Object.hasOwn(pool, name)) {
+    for (const [name, schema] of Rec.toEntries(extra)) {
+        if (!Rec.has(pool, name)) {
             pool[name] = schema;
             rememberDefinition(order, name);
             continue;
         }
-        if (JSON.stringify(pool[name]) === JSON.stringify(schema))
+        if (Formatter.formatJson(pool[name]) === Formatter.formatJson(schema))
             continue;
         const unique = uniqueName(pool, name);
         pool[unique] = schema;
@@ -132,18 +132,18 @@ function orderDefinitions(definitions, order) {
         return definitions;
     const output = {};
     for (const name of order) {
-        if (Object.hasOwn(source, name))
+        if (Rec.has(source, name))
             output[name] = source[name];
     }
-    for (const name of Object.keys(source)) {
-        if (!Object.hasOwn(output, name))
+    for (const name of Rec.keys(source)) {
+        if (!Rec.has(output, name))
             output[name] = source[name];
     }
     return output;
 }
 function uniqueName(pool, name) {
     let suffix = 2;
-    while (Object.hasOwn(pool, `${name}_${suffix}`))
+    while (Rec.has(pool, `${name}_${suffix}`))
         suffix += 1;
     return `${name}_${suffix}`;
 }
@@ -153,37 +153,12 @@ function rewriteDefName(schema, from, to) {
         return;
     if (record.$ref === `#/$defs/${from}`)
         record.$ref = `#/$defs/${to}`;
-    for (const value of Object.values(record))
+    for (const value of Rec.values(record))
         rewriteDefName(value, from, to);
 }
-function liftSiblings(value) {
-    if (Array.isArray(value))
-        return value.map((item) => liftSiblings(item));
-    const record = asRecord(value);
-    if (!record)
-        return value;
-    const lifted = {};
-    for (const [key, child] of Object.entries(record))
-        lifted[key] = liftSiblings(child);
-    if (typeof lifted.$ref !== "string")
-        return lifted;
-    const siblings = { ...lifted };
-    delete siblings.$ref;
-    // readOnly/writeOnly stay beside $ref so generators can wrap the reference itself.
-    const flags = {};
-    for (const key of ["readOnly", "writeOnly"]) {
-        if (siblings[key] === true) {
-            flags[key] = true;
-            delete siblings[key];
-        }
-    }
-    if (Object.keys(siblings).length === 0)
-        return { $ref: lifted.$ref, ...flags };
-    return { allOf: [{ $ref: lifted.$ref }, siblings], ...flags };
-}
 function recursiveNames(definitions) {
-    const names = Object.keys(definitions);
-    const dependencies = new Map(names.map((name) => [name, collectDefRefs(definitions[name])]));
+    const names = Rec.keys(definitions);
+    const dependencies = new Map(Arr.map(names, (name) => [name, collectDefRefs(definitions[name])]));
     const recursive = new Set();
     const state = new Map();
     const stack = [];
@@ -192,7 +167,7 @@ function recursiveNames(definitions) {
         if (current === 1) {
             const start = stack.indexOf(name);
             const cycle = stack.slice(start);
-            if (cycle.every((item) => isPureRef(definitions[item]))) {
+            if (Arr.every(cycle, (item) => isPureRef(definitions[item]))) {
                 throw circularAliasFailure(name);
             }
             for (const item of cycle)
@@ -215,27 +190,28 @@ function recursiveNames(definitions) {
     return recursive;
 }
 function collectDefRefs(value, found = new Set(), seen = new Set()) {
-    if (typeof value !== "object" || value === null || seen.has(value))
+    if (!Predicate.isObjectOrArray(value) || seen.has(value))
         return found;
     seen.add(value);
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         for (const item of value)
             collectDefRefs(item, found, seen);
         return found;
     }
-    const ref = value.$ref;
+    const record = value;
+    const ref = record.$ref;
     if (typeof ref === "string") {
         const key = referenceKey(ref);
         if (key)
             found.add(key);
     }
-    for (const child of Object.values(value))
+    for (const child of Rec.values(record))
         collectDefRefs(child, found, seen);
     return found;
 }
 const rootDefRef = (name) => `#/root-defs/${JsonPointer.escapeToken(name)}`;
 function resolveValue(value, definitions, rootDefs, recursive, aliases, resolving, mode, hooks, pointer) {
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         for (let index = 0; index < value.length; index++) {
             value[index] = resolveValue(value[index], definitions, rootDefs, recursive, aliases, resolving, mode, hooks, joinPointer(pointer, String(index)));
         }
@@ -246,32 +222,44 @@ function resolveValue(value, definitions, rootDefs, recursive, aliases, resolvin
         return value;
     if (typeof record.$ref === "string") {
         const key = referenceKey(record.$ref);
-        if (!key)
-            return record;
-        if (!Object.hasOwn(definitions, key)) {
+        if (key && !Rec.has(definitions, key)) {
             if (rootDefs.has(key)) {
                 record.$ref = rootDefRef(key);
-                return record;
             }
-            throw missingPointerFailure(key, record.$ref, record.$ref);
+            else {
+                throw missingPointerFailure(key, record.$ref, record.$ref);
+            }
         }
-        const final = finalName(key, definitions, aliases);
-        const ref = joinPointer("#/$defs", final);
-        if (recursive.has(final) || mode === "bundle") {
-            if (recursive.has(final))
-                hooks?.onCircular?.(pointer);
-            record.$ref = ref;
-            return record;
+        else if (key) {
+            const final = finalName(key, definitions, aliases);
+            const ref = joinPointer("#/$defs", final);
+            if (recursive.has(final) || mode === "bundle") {
+                if (recursive.has(final))
+                    hooks?.onCircular?.(pointer);
+                record.$ref = ref;
+            }
+            else {
+                if (resolving.has(final))
+                    throw circularAliasFailure(final);
+                resolving.add(final);
+                const resolved = resolveValue(structuredClone(definitions[final]), definitions, rootDefs, recursive, aliases, resolving, mode, hooks, ref);
+                resolving.delete(final);
+                const siblings = { ...record };
+                delete siblings.$ref;
+                const result = Rec.isEmptyRecord(siblings)
+                    ? resolved
+                    : {
+                        allOf: [
+                            resolved,
+                            resolveValue(siblings, definitions, rootDefs, recursive, aliases, resolving, mode, hooks, pointer),
+                        ],
+                    };
+                hooks?.onDereference?.(pointer, result, record, "$ref");
+                return result;
+            }
         }
-        if (resolving.has(final))
-            throw circularAliasFailure(final);
-        resolving.add(final);
-        const resolved = resolveValue(structuredClone(definitions[final]), definitions, rootDefs, recursive, aliases, resolving, mode, hooks, ref);
-        resolving.delete(final);
-        hooks?.onDereference?.(pointer, resolved, record, "$ref");
-        return resolved;
     }
-    for (const [key, child] of Object.entries(record)) {
+    for (const [key, child] of Rec.toEntries(record)) {
         record[key] = resolveValue(child, definitions, rootDefs, recursive, aliases, resolving, mode, hooks, joinPointer(pointer, key));
     }
     return record;
@@ -287,7 +275,7 @@ function finalName(name, definitions, aliases) {
     const schema = definitions[name];
     if (isPureRef(schema)) {
         const key = referenceKey(schema.$ref);
-        if (key && Object.hasOwn(definitions, key)) {
+        if (key && Rec.has(definitions, key)) {
             const resolved = finalName(key, definitions, aliases);
             aliases.set(name, resolved);
             return resolved;
@@ -298,10 +286,10 @@ function finalName(name, definitions, aliases) {
 }
 function isPureRef(value) {
     const record = asRecord(value);
-    return Boolean(record && typeof record.$ref === "string" && Object.keys(record).length === 1);
+    return Boolean(record && typeof record.$ref === "string" && Rec.size(record) === 1);
 }
 function referenceKey(ref) {
-    if (!ref.startsWith("#"))
+    if (!Str.startsWith("#")(ref))
         return undefined;
     const tokens = JsonPointer.parseUriFragment(ref);
     if (tokens === undefined)
@@ -313,7 +301,7 @@ function park(value, scope, id, pointer, saved) {
     if (!record)
         return;
     for (const key of ANNOTATIONS) {
-        if (!Object.hasOwn(record, key))
+        if (!Rec.has(record, key))
             continue;
         saved.push({ scope, id, pointer: [...pointer], key, value: record[key] });
         delete record[key];
@@ -321,15 +309,16 @@ function park(value, scope, id, pointer, saved) {
     for (const key of NESTED_SINGLE)
         park(record[key], scope, id, [...pointer, key], saved);
     for (const key of NESTED_ARRAY) {
-        if (!Array.isArray(record[key]))
+        const items = record[key];
+        if (!Arr.isArray(items))
             continue;
-        record[key].forEach((item, index) => park(item, scope, id, [...pointer, key, String(index)], saved));
+        Arr.forEach(items, (item, index) => park(item, scope, id, [...pointer, key, String(index)], saved));
     }
     for (const key of NESTED_MAP) {
         const map = asRecord(record[key]);
         if (!map)
             continue;
-        for (const child of Object.keys(map))
+        for (const child of Rec.keys(map))
             park(map[child], scope, id, [...pointer, key, child], saved);
     }
 }
@@ -347,7 +336,7 @@ function restore(converted, saved) {
 function descend(value, pointer) {
     let current = value;
     for (const token of pointer) {
-        if (Array.isArray(current)) {
+        if (Arr.isArray(current)) {
             current = current[Number(token)];
             continue;
         }
@@ -360,7 +349,7 @@ function descend(value, pointer) {
 }
 function restoreRootDefs(document) {
     const visit = (value) => {
-        if (Array.isArray(value)) {
+        if (Arr.isArray(value)) {
             for (const item of value)
                 visit(item);
             return;
@@ -368,19 +357,19 @@ function restoreRootDefs(document) {
         const record = asRecord(value);
         if (!record)
             return;
-        if (typeof record.$ref === "string" && record.$ref.startsWith("#/root-defs/")) {
-            const name = record.$ref.slice("#/root-defs/".length);
+        if (typeof record.$ref === "string" && Str.startsWith("#/root-defs/")(record.$ref)) {
+            const name = Str.slice("#/root-defs/".length)(record.$ref);
             record.$ref = joinPointer("#/$defs", JsonPointer.unescapeToken(name));
         }
-        for (const child of Object.values(record))
+        for (const child of Rec.values(record))
             visit(child);
     };
     visit(document);
 }
 function rewriteLeftoverDefinitionRefs(document) {
-    const names = new Set(Object.keys(asRecord(asRecord(document.components)?.schemas) ?? {}));
+    const names = new Set(Rec.keys(asRecord(asRecord(document.components)?.schemas) ?? {}));
     const visit = (value) => {
-        if (Array.isArray(value)) {
+        if (Arr.isArray(value)) {
             for (const item of value)
                 visit(item);
             return;
@@ -388,14 +377,14 @@ function rewriteLeftoverDefinitionRefs(document) {
         const record = asRecord(value);
         if (!record)
             return;
-        if (typeof record.$ref === "string" && record.$ref.startsWith("#/$defs/")) {
+        if (typeof record.$ref === "string" && Str.startsWith("#/$defs/")(record.$ref)) {
             const tokens = JsonPointer.parseUriFragment(record.$ref);
             const name = tokens?.[0] === "$defs" ? tokens[1] : undefined;
             if (name && names.has(name)) {
                 record.$ref = joinPointer("#/components/schemas", [name, ...(tokens?.slice(2) ?? [])]);
             }
         }
-        for (const child of Object.values(record))
+        for (const child of Rec.values(record))
             visit(child);
     };
     visit(document);
@@ -403,7 +392,7 @@ function rewriteLeftoverDefinitionRefs(document) {
 export function inlineRemaining(document, recursive, hooks) {
     const visiting = new Set();
     const walk = (value, parent, key, pointer = "#") => {
-        if (Array.isArray(value)) {
+        if (Arr.isArray(value)) {
             for (let index = 0; index < value.length; index++) {
                 walk(value[index], value, String(index), joinPointer(pointer, String(index)));
             }
@@ -412,7 +401,7 @@ export function inlineRemaining(document, recursive, hooks) {
         const record = asRecord(value);
         if (!record)
             return;
-        if (typeof record.$ref === "string" && record.$ref.startsWith("#") && parent && key) {
+        if (typeof record.$ref === "string" && Str.startsWith("#")(record.$ref) && parent && key) {
             const ref = record.$ref;
             const name = componentSchemaName(ref);
             if (name && recursive.has(name)) {
@@ -432,7 +421,7 @@ export function inlineRemaining(document, recursive, hooks) {
             hooks?.onDereference?.(pointer, copy, parent, key);
             return;
         }
-        for (const [childKey, child] of Object.entries(record)) {
+        for (const [childKey, child] of Rec.toEntries(record)) {
             walk(child, record, childKey, joinPointer(pointer, childKey));
         }
     };

package/dist/pointer.d.ts

@@ -1,6 +1,9 @@
+import { Option } from "effect";
 export declare function parsePointer(pointer: string, source?: string): string[];
 /** Join pointer tokens without percent-encoding, so `$` stays literal. */
 export declare function joinPointer(base: string, tokens: string | readonly string[]): string;
+/** Reads the member or array element that a JSON Pointer token names (RFC 6901). */
+export declare function childAt(value: unknown, token: string): Option.Option<unknown>;
 export declare function getAt(root: unknown, pointer: string, source?: string): unknown;
 export declare function setAt(root: object, pointer: string, value: unknown): void;
 /** Copy enumerable data, including cycles, and drop non-enumerable parser symbols. */

package/dist/pointer.js

@@ -1,11 +1,11 @@
-import { JsonPointer } from "effect";
+import { Array as Arr, JsonPointer, Option, pipe, Predicate, Record as Rec, String as Str, } from "effect";
 import { invalidPointerFailure, missingPointerFailure } from "./errors.js";
 const unsafeTokens = new Set(["__proto__", "constructor", "prototype"]);
 export function parsePointer(pointer, source = pointer) {
-    const hash = pointer.includes("#") ? pointer.slice(pointer.indexOf("#")) : pointer;
+    const hash = pipe(pointer, Str.indexOf("#"), Option.match({ onNone: () => pointer, onSome: (index) => Str.slice(index)(pointer) }));
     if (hash === "" || hash === "#")
         return [];
-    const fragment = hash.startsWith("#") ? hash : `#${hash}`;
+    const fragment = Str.startsWith("#")(hash) ? hash : `#${hash}`;
     const tokens = JsonPointer.parseUriFragment(fragment) ?? splitPointer(fragment);
     if (tokens === undefined)
         throw invalidPointerFailure(fragment, source);
@@ -13,46 +13,49 @@ export function parsePointer(pointer, source = pointer) {
 }
 /** Effect's URI-fragment parser rejects spaces. JSON Pointer tokens may contain them. */
 function splitPointer(fragment) {
-    const body = fragment.startsWith("#") ? fragment.slice(1) : fragment;
+    const body = Str.startsWith("#")(fragment) ? Str.slice(1)(fragment) : fragment;
     if (body === "")
         return [];
-    if (!body.startsWith("/"))
+    if (!Str.startsWith("/")(body))
         return undefined;
-    return body
-        .slice(1)
-        .split("/")
-        .map((token) => token.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return pipe(body, Str.slice(1), Str.split("/"), Arr.map((token) => pipe(token, Str.replace(/~1/g, "/"), Str.replace(/~0/g, "~"))));
 }
 /** Join pointer tokens without percent-encoding, so `$` stays literal. */
 export function joinPointer(base, tokens) {
     const parts = typeof tokens === "string" ? [tokens] : tokens;
-    let pointer = base.includes("#") ? base : `${base}#`;
+    let pointer = Str.includes("#")(base) ? base : `${base}#`;
     for (const token of parts)
         pointer += `/${JsonPointer.escapeToken(token)}`;
     return pointer;
 }
+const arrayIndex = /^(?:0|[1-9]\d*)$/;
+/** Reads the member or array element that a JSON Pointer token names (RFC 6901). */
+export function childAt(value, token) {
+    if (Arr.isArray(value)) {
+        return arrayIndex.test(token) ? Arr.get(value, Number(token)) : Option.none();
+    }
+    return Predicate.isObject(value) ? Rec.get(value, token) : Option.none();
+}
 export function getAt(root, pointer, source = pointer) {
     const tokens = parsePointer(pointer, source);
     let current = root;
     for (const token of tokens) {
-        if (current === null || typeof current !== "object") {
+        const child = childAt(current, token);
+        if (Option.isNone(child))
             throw missingPointerFailure(token, source, pointer);
-        }
-        if (!Object.hasOwn(current, token))
-            throw missingPointerFailure(token, source, pointer);
-        current = current[token];
+        current = child.value;
     }
     return current;
 }
 export function setAt(root, pointer, value) {
     const tokens = parsePointer(pointer, pointer);
-    if (tokens.length === 0 || tokens.some((token) => unsafeTokens.has(token)))
+    if (tokens.length === 0 || Arr.some(tokens, (token) => unsafeTokens.has(token)))
         return;
     let current = root;
     for (let index = 0; index < tokens.length - 1; index++) {
         const token = tokens[index];
         const next = current[token];
-        if (next === null || typeof next !== "object" || Array.isArray(next))
+        if (!Predicate.isObject(next))
             current[token] = {};
         current = current[token];
     }
@@ -60,21 +63,22 @@ export function setAt(root, pointer, value) {
 }
 /** Copy enumerable data, including cycles, and drop non-enumerable parser symbols. */
 export function cloneData(value, seen = new Map()) {
-    if (typeof value !== "object" || value === null)
+    if (!Predicate.isObjectOrArray(value))
         return value;
     const cached = seen.get(value);
     if (cached !== undefined)
         return cached;
-    if (Array.isArray(value)) {
+    if (Arr.isArray(value)) {
         const copy = [];
         seen.set(value, copy);
         for (const item of value)
             copy.push(cloneData(item, seen));
         return copy;
     }
+    const source = value;
     const copy = {};
-    seen.set(value, copy);
-    for (const key of Object.keys(value))
-        copy[key] = cloneData(value[key], seen);
+    seen.set(source, copy);
+    for (const key of Rec.keys(source))
+        copy[key] = cloneData(source[key], seen);
     return copy;
 }