@atolis-hq/corum 0.1.0 → 0.1.5

package/dist/src/cli.js

@@ -1,20 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { parse } from "yaml";
-import { convertOpenApiToApiEndpointDocuments, serializeApiEndpointDocument, } from "./openapi-to-api-endpoints.js";
-const [sourcePath, targetRoot] = process.argv.slice(2);
-if (!sourcePath || !targetRoot) {
-    console.error("Usage: node dist/src/cli.js <openapi-yaml> <graph-component-dir>");
-    process.exit(1);
-}
-const source = await readFile(sourcePath, "utf8");
-const openApi = parse(source);
-const component = path.basename(targetRoot);
-const outputDir = path.join(targetRoot, "api-endpoints");
-const documents = convertOpenApiToApiEndpointDocuments(openApi, { component });
-await rm(outputDir, { recursive: true, force: true });
-await mkdir(outputDir, { recursive: true });
-for (const { fileName, document } of documents) {
-    await writeFile(path.join(outputDir, fileName), serializeApiEndpointDocument(document), "utf8");
-}
-console.log(`Wrote ${documents.length} APIEndpoint files to ${outputDir}`);

package/dist/src/openapi-to-api-endpoints.js

@@ -1,240 +0,0 @@
-import { stringify } from "yaml";
-const HTTP_METHODS = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"]);
-export function convertOpenApiToApiEndpointDocuments(openApi, options) {
-    const output = [];
-    for (const [path, pathItem] of Object.entries(openApi.paths ?? {})) {
-        if (!isRecord(pathItem)) {
-            continue;
-        }
-        for (const [method, operation] of Object.entries(pathItem)) {
-            if (!HTTP_METHODS.has(method) || !isRecord(operation)) {
-                continue;
-            }
-            const slug = slugify(operation.operationId ?? `${method}-${path}`);
-            const ctx = {
-                openApi,
-                schemas: {},
-                enums: {},
-                schemaNamesInProgress: new Set(),
-            };
-            const properties = {
-                method: method.toUpperCase(),
-                path,
-                responses: {},
-            };
-            const requestSchema = firstContentSchema(operation.requestBody?.content);
-            if (requestSchema) {
-                const requestName = `${slug}-request`;
-                createSchema(requestName, requestSchema, ctx, operation.requestBody?.description);
-                properties.request = requestName;
-            }
-            for (const [status, response] of Object.entries(operation.responses ?? {})) {
-                if (!isRecord(response)) {
-                    continue;
-                }
-                const responseName = `${slug}-response-${status}`;
-                const responseSchema = firstContentSchema(response.content);
-                if (responseSchema) {
-                    createSchema(responseName, responseSchema, ctx, response.description);
-                }
-                else {
-                    createEmptyBodySchema(responseName, response.description, ctx);
-                }
-                properties.responses[status] = responseName;
-            }
-            const document = {
-                "schema-version": "1.0",
-                id: `${options.component}.api-endpoints.${slug}`,
-                template: "APIEndpoint",
-                state: "proposed",
-                stability: "unstable",
-                name: `${method.toUpperCase()} ${path}`,
-                ...(operation.description || operation.summary
-                    ? { description: operation.description ?? operation.summary }
-                    : {}),
-                properties,
-                schemas: ctx.schemas,
-            };
-            if (Object.keys(ctx.enums).length > 0) {
-                document.enums = ctx.enums;
-            }
-            output.push({
-                fileName: `${slug}.yaml`,
-                document,
-            });
-        }
-    }
-    return output.sort((left, right) => left.fileName.localeCompare(right.fileName));
-}
-export function serializeApiEndpointDocument(document) {
-    return stringify(document, {
-        lineWidth: 0,
-        sortMapEntries: false,
-    });
-}
-function createSchema(name, sourceSchema, ctx, description) {
-    if (ctx.schemas[name] || ctx.schemaNamesInProgress.has(name)) {
-        return;
-    }
-    ctx.schemaNamesInProgress.add(name);
-    ctx.schemas[name] = {
-        ...(description ? { description } : {}),
-        fields: {},
-    };
-    const schema = resolveSchema(sourceSchema, ctx.openApi);
-    const logicalName = typeof sourceSchema.$ref === "string" ? refTail(sourceSchema.$ref) : name;
-    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-    const fields = {};
-    if (schema.type === "array") {
-        fields.items = createField(`${name}Item`, schema.items ?? {}, ctx, false, logicalName);
-        fields.items.cardinality = "many";
-    }
-    else if (schema.type === "object" || isRecord(schema.properties) || isRecord(schema.additionalProperties)) {
-        for (const [fieldName, propertySchema] of Object.entries(schema.properties ?? {})) {
-            if (!isRecord(propertySchema)) {
-                continue;
-            }
-            fields[fieldName] = createField(fieldName, propertySchema, ctx, required.has(fieldName), logicalName);
-        }
-        if (Object.keys(fields).length === 0 && isRecord(schema.additionalProperties)) {
-            fields.additionalProperties = createField("additionalProperties", schema.additionalProperties, ctx, true, logicalName);
-        }
-    }
-    else {
-        fields.value = createField("value", schema, ctx, true, logicalName);
-    }
-    ctx.schemas[name] = {
-        ...(description || schema.description ? { description: description ?? schema.description } : {}),
-        fields,
-    };
-    ctx.schemaNamesInProgress.delete(name);
-}
-function createEmptyBodySchema(name, description, ctx) {
-    ctx.schemas[name] = {
-        ...(description ? { description } : {}),
-        fields: {
-            message: {
-                scalarType: "string",
-                nullable: true,
-                cardinality: "one",
-            },
-        },
-    };
-}
-function createField(fieldName, sourceSchema, ctx, required, ownerName) {
-    const cardinality = sourceSchema.type === "array" ? "many" : "one";
-    const schema = sourceSchema.type === "array" && isRecord(sourceSchema.items) ? sourceSchema.items : sourceSchema;
-    if (isRecord(schema) && typeof schema.$ref === "string") {
-        const refName = refTail(schema.$ref);
-        const target = resolveSchema(schema, ctx.openApi);
-        createSchema(refName, target, ctx, target.description);
-        return {
-            objectRef: refName,
-            nullable: !required,
-            cardinality,
-        };
-    }
-    if (Array.isArray(schema.enum)) {
-        const enumName = enumNameFor(ownerName, fieldName);
-        ctx.enums[enumName] = {
-            ...(schema.description ? { description: schema.description } : {}),
-            values: Object.fromEntries(schema.enum.map((value) => [
-                slugify(String(value)),
-                {
-                    name: String(value),
-                },
-            ])),
-        };
-        return {
-            objectRef: enumName,
-            nullable: !required,
-            cardinality,
-        };
-    }
-    if (schema.type === "object" || isRecord(schema.properties) || isRecord(schema.additionalProperties)) {
-        const objectName = pascalCase(fieldName);
-        createSchema(objectName, schema, ctx, schema.description);
-        return {
-            objectRef: objectName,
-            nullable: !required,
-            cardinality,
-        };
-    }
-    return {
-        scalarType: scalarTypeFor(schema),
-        nullable: !required,
-        cardinality,
-    };
-}
-function firstContentSchema(content) {
-    if (!isRecord(content)) {
-        return undefined;
-    }
-    const mediaType = ["application/json", "application/xml", "application/x-www-form-urlencoded"].find((type) => isRecord(content[type]?.schema)) ?? Object.keys(content).find((type) => isRecord(content[type]?.schema));
-    if (!mediaType) {
-        return undefined;
-    }
-    return content[mediaType].schema;
-}
-function resolveSchema(schema, openApi) {
-    if (typeof schema.$ref !== "string") {
-        return schema;
-    }
-    const pointer = schema.$ref.replace(/^#\//, "").split("/");
-    let current = openApi;
-    for (const segment of pointer) {
-        current = current?.[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
-    }
-    if (!isRecord(current)) {
-        throw new Error(`Unable to resolve OpenAPI reference ${schema.$ref}`);
-    }
-    return current;
-}
-function scalarTypeFor(schema) {
-    if (schema.type === "integer") {
-        return "integer";
-    }
-    if (schema.type === "number") {
-        return "decimal";
-    }
-    if (schema.type === "boolean") {
-        return "boolean";
-    }
-    if (schema.type === "string" && schema.format === "date-time") {
-        return "datetime";
-    }
-    if (schema.type === "string" && schema.format === "date") {
-        return "date";
-    }
-    if (schema.type === "string" && schema.format === "time") {
-        return "time";
-    }
-    return "string";
-}
-function enumNameFor(ownerName, fieldName) {
-    if (fieldName.toLowerCase() === "status") {
-        return `${pascalCase(ownerName)}Status`;
-    }
-    return `${pascalCase(ownerName)}${pascalCase(fieldName)}`;
-}
-function refTail(ref) {
-    return ref.split("/").at(-1) ?? ref;
-}
-function slugify(value) {
-    return value
-        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-        .replace(/[^a-zA-Z0-9]+/g, "-")
-        .replace(/^-|-$/g, "")
-        .toLowerCase();
-}
-function pascalCase(value) {
-    return value
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .split(/[^a-zA-Z0-9]+/)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join("");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}