@kubun/protocol 0.3.10 → 0.4.0

package/lib/models/cluster.js

@@ -1,156 +1,9 @@
 import { toB64 } from '@enkaku/codec';
 import { assertType, createValidator } from '@enkaku/schema';
-import { DocumentModelID, digestJSON, ScalarModelID, ShapeModelID } from '@kubun/id';
-import { pascalCase } from 'change-case';
-import { documentModel, documentModelsCluster } from './document.js';
+import { DocumentModelID, digestJSON } from '@kubun/id';
+import { getKubunLogger } from '@kubun/logger';
+import { DocumentModelNormalizer, documentModelsCluster } from './document.js';
 import { binaryStringValue } from './value.js';
-const JSONObjectSchema = {
-    type: 'object',
-    title: 'JSONObject',
-    additionalProperties: true
-};
-export const REFERENCE_PREFIX = '#/$defs/';
-function toReference(id) {
-    return `${REFERENCE_PREFIX}${id}`;
-}
-function resolveReference(root, ref) {
-    if (!ref.startsWith('#')) {
-        throw new Error(`Invalid reference format: ${ref}`);
-    }
-    // Handle #/$defs/ references
-    if (ref.startsWith(REFERENCE_PREFIX)) {
-        const key = ref.slice(REFERENCE_PREFIX.length);
-        const resolved = root.$defs?.[key];
-        if (resolved == null) {
-            throw new Error(`Reference not found: ${ref}`);
-        }
-        return resolved;
-    }
-    // Handle other JSON Schema references like #/properties/, #/items/, etc.
-    const segments = ref.split('/').slice(1);
-    // biome-ignore lint/suspicious/noExplicitAny: mixed type
-    let current = root;
-    for (const segment of segments){
-        if (current == null || typeof current !== 'object') {
-            throw new Error(`Invalid reference path: ${ref}`);
-        }
-        current = current[segment];
-        if (current == null) {
-            throw new Error(`Reference not found: ${ref}`);
-        }
-    }
-    return current;
-}
-function addScalar(refs, schema) {
-    const id = ScalarModelID.create(schema);
-    let normalizedSchema = schema;
-    if (schema.type === 'boolean') {
-        const { title: _, ...rest } = schema;
-        normalizedSchema = rest;
-    } else if (schema.title != null) {
-        normalizedSchema = {
-            ...schema,
-            title: pascalCase(schema.title)
-        };
-    }
-    refs[id.toString()] = normalizedSchema;
-    return toReference(id);
-}
-function addShape(refs, schema) {
-    const id = ShapeModelID.create(schema);
-    refs[id.toString()] = schema;
-    return toReference(id);
-}
-function encodeSchema(root, refs, schema) {
-    if (schema.$ref != null) {
-        const resolvedSchema = resolveReference(root, schema.$ref);
-        return encodeSchema(root, refs, resolvedSchema);
-    }
-    const type = schema.type;
-    if (type == null) {
-        throw new Error('Invalid schema: missing type');
-    }
-    switch(type){
-        case 'array':
-            {
-                if (schema.title == null) {
-                    throw new Error('Invalid array schema: missing title');
-                }
-                if (schema.items == null) {
-                    throw new Error('Invalid array schema: missing items');
-                }
-                const { default: _, ...rest } = schema;
-                return addShape(refs, {
-                    ...rest,
-                    title: pascalCase(schema.title),
-                    items: {
-                        $ref: encodeSchema(root, refs, schema.items)
-                    }
-                });
-            }
-        case 'object':
-            {
-                if (schema.additionalProperties) {
-                    return addShape(refs, JSONObjectSchema);
-                }
-                if (schema.title == null) {
-                    throw new Error('Invalid object schema: missing title');
-                }
-                const entries = Object.entries(schema.properties ?? {});
-                if (entries.length === 0) {
-                    throw new Error('Invalid object schema: must contain at least one property');
-                }
-                const properties = {};
-                for (const [key, value] of entries){
-                    properties[key] = {
-                        $ref: encodeSchema(root, refs, value)
-                    };
-                }
-                return addShape(refs, {
-                    type: 'object',
-                    title: pascalCase(schema.title),
-                    properties,
-                    required: schema.required ?? [],
-                    additionalProperties: false
-                });
-            }
-        default:
-            return addScalar(refs, schema);
-    }
-}
-function normalizeDocumentSchema(schema) {
-    const entries = Object.entries(schema.properties ?? {});
-    if (entries.length === 0) {
-        throw new Error('Document schema must contain at least one property');
-    }
-    const properties = {};
-    const refs = schema.$defs ?? {};
-    for (const [key, value] of entries){
-        properties[key] = {
-            $ref: encodeSchema(schema, refs, value)
-        };
-    }
-    return {
-        type: 'object',
-        properties,
-        additionalProperties: false,
-        required: schema.required ?? [],
-        $defs: refs
-    };
-}
-const LOCAL_ID_REGEXP = /^#([0-9]+)$/;
-function normalizeFieldsMeta(fields) {
-    const meta = {};
-    for (const [key, field] of Object.entries(fields)){
-        const match = field.relationModel?.match(LOCAL_ID_REGEXP);
-        meta[key] = match == null ? field : {
-            ...field,
-            relationModel: DocumentModelID.local(Number.parseInt(match[1], 10)).toString()
-        };
-    }
-    return meta;
-}
-export const validateDocumentModel = createValidator(documentModel);
 export const clusterModel = {
     $id: 'urn:kubun:protocol:model:cluster',
     type: 'object',
@@ -202,6 +55,10 @@ export function verifyCluster(cluster) {
 }
 export class ClusterBuilder {
     #cluster = [];
+    #logger;
+    constructor(params = {}){
+        this.#logger = params.logger ?? getKubunLogger('protocol');
+    }
     get cluster() {
         return this.#cluster;
     }
@@ -248,13 +105,7 @@ export class ClusterBuilder {
         return model;
     }
     add(inputModel) {
-        const inputSchema = inputModel.schema ?? {};
         const interfaceIDs = inputModel.interfaces ?? [];
-        const interfaces = new Set();
-        const schemaProperties = {};
-        const schemaReferences = {};
-        const schemaRequired = new Set();
-        const fieldsMeta = {};
         const normalizedInterfaceIDs = interfaceIDs.map((id)=>{
             if (id.startsWith('#')) {
                 const index = Number.parseInt(id.slice(1), 10);
@@ -265,55 +116,17 @@ export class ClusterBuilder {
             }
             return id;
         });
-        // Add interface fields
-        for (const interfaceModel of normalizedInterfaceIDs.map((id)=>this.get(id))){
-            for (const interfaceID of interfaceModel.interfaces){
-                interfaces.add(interfaceID);
-            }
-            for (const requiredKey of interfaceModel.schema.required){
-                schemaRequired.add(requiredKey);
-            }
-            Object.assign(schemaProperties, interfaceModel.schema.properties);
-            Object.assign(schemaReferences, interfaceModel.schema.$defs);
-            Object.assign(fieldsMeta, interfaceModel.fieldsMeta ?? {});
-        }
-        // Add model extra fields
-        for (const interfaceID of normalizedInterfaceIDs){
-            interfaces.add(interfaceID);
-        }
-        for (const requiredKey of inputSchema.required ?? []){
-            schemaRequired.add(requiredKey);
-        }
-        Object.assign(schemaProperties, inputSchema.properties ?? {});
-        Object.assign(fieldsMeta, inputModel.fieldsMeta ?? {});
+        const model = new DocumentModelNormalizer({
+            inputModel,
+            interfaceModels: normalizedInterfaceIDs.map((id)=>this.get(id)),
+            logger: this.#logger,
+            normalizedInterfaceIDs
+        }).toDocumentModel();
         const index = this.#cluster.length;
-        const model = {
-            version: '1.0',
-            behavior: 'default',
-            ...inputModel,
-            interfaces: Array.from(interfaces),
-            schema: normalizeDocumentSchema({
-                ...inputSchema,
-                type: 'object',
-                properties: schemaProperties,
-                required: Array.from(schemaRequired),
-                additionalProperties: false,
-                $defs: {
-                    ...inputSchema.$defs,
-                    ...schemaReferences
-                }
-            }),
-            fieldsMeta: normalizeFieldsMeta(fieldsMeta)
-        };
-        assertType(validateDocumentModel, model);
         this.#cluster.push(model);
         return DocumentModelID.local(index);
     }
     addAll(models) {
-        const ids = [];
-        for (const model of models){
-            ids.push(this.add(model));
-        }
-        return ids;
+        return models.map((input)=>this.add(input));
     }
 }