@m6d/cortex-cli 0.12.1 → 0.14.0

package/src/swagger/openapi-schema.ts

@@ -1,168 +0,0 @@
-/**
- * Reading an OpenAPI document: following $ref, deciding a schema's type, and turning
- * a schema into the flat property list the generator emits. Nothing here knows what
- * the properties are for.
- */
-import { isRecord } from "@cortex/contracts/json";
-import type { Obj, Prop } from "./types";
-
-const MAX_DEPTH = 8;
-
-export function obj(v: unknown) {
-    return isRecord(v) ? v : {};
-}
-
-function strings(v: unknown) {
-    return Array.isArray(v) ? v.filter((x): x is string => typeof x === "string") : [];
-}
-
-/** The first prop of each name. */
-export function dedupe(items: Prop[]) {
-    const seen = new Set<string>();
-    return items.filter((prop) => {
-        if (seen.has(prop.name)) return false;
-        seen.add(prop.name);
-        return true;
-    });
-}
-
-function resolvePointer(doc: unknown, ref: string) {
-    if (!ref.startsWith("#/")) return null;
-    let cur: unknown = doc;
-    for (const part of ref.slice(2).split("/")) {
-        const key = part.replace(/~1/g, "/").replace(/~0/g, "~");
-        if (!isRecord(cur) || !(key in cur)) return null;
-        cur = cur[key];
-    }
-    return cur;
-}
-
-export function deref(doc: unknown, v: unknown) {
-    if (!isRecord(v)) return {};
-    let x = v;
-    const seen = new Set<string>();
-    while (typeof x.$ref === "string") {
-        if (seen.has(x.$ref)) return {};
-        seen.add(x.$ref);
-        x = obj(resolvePointer(doc, x.$ref));
-    }
-    return x;
-}
-
-export function schemaType(s: Obj) {
-    const t = Array.isArray(s.type)
-        ? (s.type as unknown[]).find((x) => typeof x === "string" && x !== "null")
-        : s.type;
-    if (typeof t === "string") return t;
-    if (isRecord(s.properties)) return "object";
-    if (isRecord(s.items)) return "array";
-    return "";
-}
-
-function isJsonNodeRef(v: unknown) {
-    return (
-        isRecord(v) &&
-        typeof v.$ref === "string" &&
-        /\/System\.Text\.Json\.Nodes\.JsonNode$/.test(v.$ref)
-    );
-}
-
-function isJsonNodeSchema(s: Obj) {
-    const p = obj(s.properties);
-    return (
-        schemaType(s) === "object" &&
-        "options" in p &&
-        "parent" in p &&
-        "root" in p &&
-        isJsonNodeRef(p.parent) &&
-        isJsonNodeRef(p.root)
-    );
-}
-
-function scalarType(s: Obj) {
-    if (Array.isArray(s.enum) && s.enum.every((v) => typeof v === "string")) {
-        return s.enum.map((v) => `'${String(v).replace(/'/g, "\\'")}'`).join(" | ");
-    }
-    const t = schemaType(s);
-    const f = typeof s.format === "string" ? s.format : "";
-    if (f === "uuid") return "uuid";
-    if (f === "date") return "date";
-    if (f === "date-time") return "datetime";
-    if (t === "integer" || t === "number") return "number";
-    if (t === "boolean") return "boolean";
-    if (t === "string") return "string";
-    if (t === "object") return "object";
-    return "unknown";
-}
-
-export function toProps(doc: unknown, schemaIn: unknown, depth = 0) {
-    if (depth > MAX_DEPTH) return [];
-    const s = deref(doc, schemaIn);
-    if (isJsonNodeRef(schemaIn) || isJsonNodeSchema(s)) return [];
-    const req = new Set(strings(s.required));
-    return dedupe(
-        Object.entries(obj(s.properties)).map(([name, child]) =>
-            toProp(doc, name, child, req.has(name), depth + 1),
-        ),
-    );
-}
-
-export function toProp(
-    doc: unknown,
-    name: string,
-    schemaIn: unknown,
-    required: boolean,
-    depth = 0,
-    // eslint-disable-next-line m6d/no-explicit-return-type -- mutually recursive with toProps, so the return type cannot be inferred
-): Prop {
-    if (isJsonNodeRef(schemaIn)) return { name, required, type: "object" };
-
-    const s = deref(doc, schemaIn);
-    const req = required && s.nullable !== true;
-
-    if (isJsonNodeSchema(s)) return { name, required: req, type: "object" };
-
-    const t = schemaType(s);
-    if (t === "array") {
-        const item = deref(doc, s.items);
-        if (schemaType(item) === "object") {
-            const properties = toProps(doc, item, depth + 1);
-            return {
-                name,
-                required: req,
-                type: "object",
-                isArray: true,
-                ...(properties.length ? { properties } : {}),
-            };
-        }
-        return { name, required: req, type: scalarType(item), isArray: true };
-    }
-
-    if (t === "object") {
-        const properties = toProps(doc, s, depth + 1);
-        return {
-            name,
-            required: req,
-            type: "object",
-            ...(properties.length ? { properties } : {}),
-        };
-    }
-
-    return { name, required: req, type: scalarType(s) };
-}
-
-/**
- * The schema under `application/json`, else any JSON type, else the first
- * type, along with every type offered.
- */
-export function pickContent(contentIn: unknown) {
-    const content = obj(contentIn);
-    const mimes = Object.keys(content);
-    const [first] = mimes;
-    if (first === undefined) return null;
-    const mime =
-        mimes.find((x) => x.toLowerCase() === "application/json") ??
-        mimes.find((x) => x.toLowerCase().includes("json")) ??
-        first;
-    return { schema: obj(content[mime]).schema, mimes };
-}

package/src/swagger/parse-response.ts

@@ -1,88 +0,0 @@
-/**
- * Deciding what an endpoint answers with: which statuses it uses, and what shape the
- * success body takes. The shape is what drives code generation, so a paged envelope
- * is reported as the rows it wraps rather than as its own page fields.
- */
-import type { Obj, Prop, ResponseKind } from "./types";
-import { deref, obj, pickContent, schemaType, toProp, toProps } from "./openapi-schema";
-
-type ResponseBody = { responseKind: ResponseKind; response: Prop[] };
-
-const NO_BODY = { responseKind: "none", response: [] } satisfies ResponseBody;
-
-const FILE_MIME = /(application\/octet-stream|application\/pdf|application\/vnd\.|text\/csv)/i;
-
-/** An object contributes its own fields; anything else stands as a single `item`. */
-function itemProps(doc: unknown, item: Obj) {
-    return schemaType(item) === "object" ? toProps(doc, item) : [toProp(doc, "item", item, true)];
-}
-
-function isFileResponse(mimes: string[], schema: Obj) {
-    if (mimes.some((mime) => FILE_MIME.test(mime))) return true;
-
-    return (
-        schemaType(schema) === "string" &&
-        typeof schema.format === "string" &&
-        ["binary", "base64"].includes(schema.format)
-    );
-}
-
-/** A paged envelope is described by the items it wraps, not by its own page fields. */
-function parseObjectBody(doc: unknown, schema: Obj) {
-    const props = obj(schema.properties);
-    const hasPaging = ["totalCount", "pageNumber", "pageSize", "totalPages"].some(
-        (k) => k in props,
-    );
-    const list = deref(doc, props.items ?? props.data ?? props.results);
-
-    if (hasPaging && schemaType(list) === "array") {
-        return {
-            responseKind: "paginated",
-            response: itemProps(doc, deref(doc, list.items)),
-        } satisfies ResponseBody;
-    }
-
-    return { responseKind: "object", response: toProps(doc, schema) } satisfies ResponseBody;
-}
-
-function parseResponseBody(doc: unknown, schema: Obj, mimes: string[]) {
-    if (isFileResponse(mimes, schema))
-        return { responseKind: "file", response: [] } satisfies ResponseBody;
-
-    const type = schemaType(schema);
-    if (type === "array") {
-        return {
-            responseKind: "array",
-            response: itemProps(doc, deref(doc, schema.items)),
-        } satisfies ResponseBody;
-    }
-    if (type === "object") return parseObjectBody(doc, schema);
-    if (Object.keys(schema).length) {
-        return {
-            responseKind: "object",
-            response: [toProp(doc, "value", schema, true)],
-        } satisfies ResponseBody;
-    }
-
-    return NO_BODY;
-}
-
-export function parseResponse(doc: unknown, responsesIn: unknown) {
-    const responses = obj(responsesIn);
-    const statuses = Object.keys(responses)
-        .map(Number)
-        .filter(Number.isInteger)
-        .sort((a, b) => a - b);
-    const successStatus = statuses.find((s) => s >= 200 && s < 300) ?? 200;
-    const errorStatuses = [...new Set(statuses.filter((s) => s >= 400))];
-
-    // 204 says there is no body at all, so there is nothing further to read.
-    if (successStatus === 204) return { successStatus, errorStatuses, ...NO_BODY };
-
-    const success = deref(doc, responses[String(successStatus)]);
-    const content = pickContent(success.content);
-    if (!content) return { successStatus, errorStatuses, ...NO_BODY };
-
-    const body = parseResponseBody(doc, deref(doc, content.schema), content.mimes);
-    return { successStatus, errorStatuses, ...body };
-}

package/src/swagger/types.ts

@@ -1,25 +0,0 @@
-/**
- * The shapes shared across endpoint extraction: what an OpenAPI document looks like
- * on the way in, and what one generated endpoint looks like on the way out.
- */
-export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
-export type ResponseKind = "object" | "array" | "paginated" | "file" | "none";
-export type Obj = Record<string, unknown>;
-export type Prop = {
-    name: string;
-    required: boolean;
-    type: string;
-    isArray?: boolean;
-    properties?: Prop[];
-};
-export type Endpoint = {
-    key: string;
-    method: HttpMethod;
-    path: string;
-    params: Prop[];
-    body: Prop[];
-    response: Prop[];
-    responseKind: ResponseKind;
-    successStatus: number;
-    errorStatuses: number[];
-};