@unispechq/unispec-core 0.1.0 → 0.1.1

package/dist/normalizer/index.js

@@ -1,116 +0,0 @@
-function isPlainObject(value) {
-    return Object.prototype.toString.call(value) === "[object Object]";
-}
-function normalizeValue(value) {
-    if (Array.isArray(value)) {
-        return value.map((item) => normalizeValue(item));
-    }
-    if (isPlainObject(value)) {
-        const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
-        const normalized = {};
-        for (const [key, val] of entries) {
-            normalized[key] = normalizeValue(val);
-        }
-        return normalized;
-    }
-    return value;
-}
-function normalizeRestPaths(doc) {
-    if (!doc || !doc.service || !doc.service.protocols) {
-        return doc;
-    }
-    const protocols = doc.service.protocols;
-    const rest = protocols.rest;
-    if (!rest || !rest.paths || typeof rest.paths !== "object") {
-        return doc;
-    }
-    const httpMethodOrder = ["get", "head", "options", "post", "put", "patch", "delete"];
-    const normalizedPaths = {};
-    for (const path of Object.keys(rest.paths).sort()) {
-        const pathItem = rest.paths[path];
-        if (!pathItem || typeof pathItem !== "object") {
-            normalizedPaths[path] = pathItem;
-            continue;
-        }
-        const pathItemObj = pathItem;
-        const ordered = {};
-        for (const method of httpMethodOrder) {
-            if (Object.prototype.hasOwnProperty.call(pathItemObj, method)) {
-                ordered[method] = pathItemObj[method];
-            }
-        }
-        const remainingKeys = Object.keys(pathItemObj).filter((k) => !httpMethodOrder.includes(k)).sort();
-        for (const key of remainingKeys) {
-            ordered[key] = pathItemObj[key];
-        }
-        normalizedPaths[path] = ordered;
-    }
-    rest.paths = normalizedPaths;
-    return doc;
-}
-function normalizeWebSocket(doc) {
-    if (!doc || !doc.service || !doc.service.protocols) {
-        return doc;
-    }
-    const protocols = doc.service.protocols;
-    const websocket = protocols.websocket;
-    if (!websocket || !websocket.channels || typeof websocket.channels !== "object") {
-        return doc;
-    }
-    const originalChannels = websocket.channels;
-    const sortedChannels = {};
-    for (const name of Object.keys(originalChannels).sort()) {
-        const channel = originalChannels[name];
-        if (!channel) {
-            continue;
-        }
-        let messages = channel.messages;
-        if (Array.isArray(messages)) {
-            messages = [...messages].sort((a, b) => {
-                const aName = a?.name ?? "";
-                const bName = b?.name ?? "";
-                return aName.localeCompare(bName);
-            });
-        }
-        sortedChannels[name] = {
-            ...channel,
-            ...(messages ? { messages } : {}),
-        };
-    }
-    websocket.channels = sortedChannels;
-    return doc;
-}
-function normalizeGraphqlOperations(doc) {
-    if (!doc || !doc.service || !doc.service.protocols) {
-        return doc;
-    }
-    const protocols = doc.service.protocols;
-    const graphql = protocols.graphql;
-    if (!graphql || !graphql.operations) {
-        return doc;
-    }
-    const kinds = ["queries", "mutations", "subscriptions"];
-    for (const kind of kinds) {
-        const bucket = graphql.operations[kind];
-        if (!bucket || typeof bucket !== "object") {
-            continue;
-        }
-        const sorted = {};
-        for (const name of Object.keys(bucket).sort()) {
-            sorted[name] = bucket[name];
-        }
-        graphql.operations[kind] = sorted;
-    }
-    return doc;
-}
-/**
- * Normalize a UniSpec document into a canonical, deterministic form.
- *
- * Current behavior:
- * - Recursively sorts object keys lexicographically.
- * - Preserves values as-is.
- */
-export function normalizeUniSpec(doc, _options = {}) {
-    const normalized = normalizeValue(doc);
-    return normalizeWebSocket(normalizeGraphqlOperations(normalizeRestPaths(normalized)));
-}

package/dist/types/index.d.ts

@@ -1,57 +0,0 @@
-export interface UniSpecGraphQLSchema {
-    sdl?: string;
-}
-export interface UniSpecGraphQLOperations {
-    queries?: Record<string, unknown>;
-    mutations?: Record<string, unknown>;
-    subscriptions?: Record<string, unknown>;
-}
-export interface UniSpecGraphQLProtocol {
-    schema?: UniSpecGraphQLSchema;
-    operations?: UniSpecGraphQLOperations;
-    extensions?: Record<string, unknown>;
-}
-export interface UniSpecWebSocketMessage {
-    name?: string;
-    summary?: string;
-    description?: string;
-    payload?: unknown;
-    extensions?: Record<string, unknown>;
-}
-export interface UniSpecWebSocketChannel {
-    summary?: string;
-    title?: string;
-    description?: string;
-    direction?: string;
-    messages?: UniSpecWebSocketMessage[];
-    extensions?: Record<string, unknown>;
-}
-export interface UniSpecWebSocketProtocol {
-    channels?: Record<string, UniSpecWebSocketChannel>;
-    extensions?: Record<string, unknown>;
-}
-export interface UniSpecServiceProtocols {
-    rest?: unknown;
-    graphql?: UniSpecGraphQLProtocol;
-    websocket?: UniSpecWebSocketProtocol;
-}
-export interface UniSpecService {
-    name: string;
-    title?: string;
-    description?: string;
-    protocols?: UniSpecServiceProtocols;
-}
-export interface UniSpecDocument {
-    unispecVersion: string;
-    service: UniSpecService;
-    extensions?: Record<string, unknown>;
-}
-export interface ValidationError {
-    message: string;
-    path?: string;
-    code?: string;
-}
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-}

package/dist/types/index.js

@@ -1 +0,0 @@
-export {};

package/dist/validator/index.d.ts

@@ -1,7 +0,0 @@
-import { UniSpecDocument, ValidationResult } from "../types";
-export interface ValidateOptions {
-}
-/**
- * Validate a UniSpec document against the UniSpec JSON Schema.
- */
-export declare function validateUniSpec(doc: UniSpecDocument, _options?: ValidateOptions): Promise<ValidationResult>;

package/dist/validator/index.js

@@ -1,47 +0,0 @@
-import Ajv2020 from "ajv/dist/2020.js";
-import { createRequire } from "module";
-import { unispec as unispecSchema, manifest as unispecManifest } from "@unispechq/unispec-schema";
-const require = createRequire(import.meta.url);
-const ajv = new Ajv2020({
-    allErrors: true,
-    strict: true,
-});
-// Register all UniSpec subschemas so that Ajv can resolve internal $ref links
-try {
-    const schemaRootPath = require.resolve("@unispechq/unispec-schema");
-    const schemaDir = schemaRootPath.replace(/index\.(cjs|mjs|js)$/u, "schema/");
-    const types = unispecManifest?.types ?? {};
-    const typeSchemaPaths = Object.values(types).map((rel) => String(rel));
-    const loadedTypeSchemas = typeSchemaPaths.map((relPath) => require(schemaDir + relPath));
-    ajv.addSchema(loadedTypeSchemas);
-}
-catch {
-    // If subschemas cannot be loaded for some reason, validation will still work for
-    // parts of the schema that do not rely on those $ref references.
-}
-const validateFn = ajv.compile(unispecSchema);
-function mapAjvErrors(errors) {
-    if (!errors)
-        return [];
-    return errors.map((error) => ({
-        message: error.message || "UniSpec validation error",
-        path: error.instancePath || error.schemaPath,
-        code: error.keyword,
-    }));
-}
-/**
- * Validate a UniSpec document against the UniSpec JSON Schema.
- */
-export async function validateUniSpec(doc, _options = {}) {
-    const valid = validateFn(doc);
-    if (valid) {
-        return {
-            valid: true,
-            errors: [],
-        };
-    }
-    return {
-        valid: false,
-        errors: mapAjvErrors(validateFn.errors),
-    };
-}