@atolis-hq/corum 0.1.14 → 0.1.15

package/dist/src/adapters/openapi/mapper.js

@@ -229,18 +229,16 @@ function extractParameters(pathItem, operation, packConfig, specPath, diagnostic
         if (!schema)
             continue;
         let type;
-        let cardinality;
+        let collection;
         if (schema.type === 'array') {
-            cardinality = 'many';
+            collection = 'array';
             const items = schema.items;
             type = deriveScalarType(items?.type ?? 'string', items?.format, packConfig.scalarTypes) ?? 'string';
         }
         else if (schema.enum) {
-            cardinality = 'one';
             type = 'string';
         }
         else {
-            cardinality = 'one';
             const derived = deriveScalarType(schema.type ?? 'string', schema.format, packConfig.scalarTypes);
             if (!derived) {
                 diagnostics.push({ severity: 'warning', file: specPath, message: `Unknown type for parameter ${name}: ${schema.type}/${schema.format}, defaulting to string` });
@@ -254,7 +252,7 @@ function extractParameters(pathItem, operation, packConfig, specPath, diagnostic
             location: param.in,
             type,
             required: param.required ?? false,
-            cardinality,
+            ...(collection ? { collection } : {}),
         };
     }
     return Object.keys(parameters).length > 0 ? parameters : undefined;
@@ -308,10 +306,10 @@ function createInlineSchema(schema, name, parentId, section, rootId, packConfig,
     emitFields(schema, schemaId, 'fields', rootId, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
     return localRef;
 }
-function resolveFieldRef(schemaName, cardinality, keyed, required, rootId, readsSource, refSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas) {
-    const extra = { nullable: !required, cardinality };
-    if (keyed)
-        extra.keyed = true;
+function resolveFieldRef(schemaName, collection, required, rootId, readsSource, refSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas) {
+    const extra = { nullable: !required };
+    if (collection !== 'one')
+        extra.collection = collection;
     const globalId = sharedSchemas.get(schemaName);
     if (globalId) {
         emitReadsEdge(readsSource, globalId, edges);
@@ -336,26 +334,26 @@ function emitFields(schema, parentId, section, rootId, packConfig, specPath, nod
         const fieldNode = makeNode(packConfig.constructs.schemaProperty?.template ?? 'Field', component, specPath, fieldId);
         const required = Array.isArray(schema.required) && schema.required.includes(fieldName);
         if (isRefSchema(fieldSchema)) {
-            fieldNode.properties = resolveFieldRef(refName(fieldSchema.$ref), 'one', false, required, rootId, readsSource, fieldSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
+            fieldNode.properties = resolveFieldRef(refName(fieldSchema.$ref), 'one', required, rootId, readsSource, fieldSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
         }
         else {
             const fs = fieldSchema;
             if (fs.enum && fs.type !== 'object') {
                 const enumRef = sharedSchemas.get(fieldName);
-                fieldNode.properties = { ...(enumRef ? { $ref: enumRef } : { type: 'string' }), nullable: !required, cardinality: 'one' };
+                fieldNode.properties = { ...(enumRef ? { $ref: enumRef } : { type: 'string' }), nullable: !required };
             }
             else if (fs.type === 'array') {
                 const rawItems = fs.items;
                 const items = rawItems ? resolveAllOfRef(rawItems) : undefined;
                 if (!items) {
-                    fieldNode.properties = { type: 'string', nullable: !required, cardinality: 'many' };
+                    fieldNode.properties = { type: 'string', nullable: !required, collection: 'array' };
                 }
                 else if (isRefSchema(items)) {
-                    fieldNode.properties = resolveFieldRef(refName(items.$ref), 'many', false, required, rootId, readsSource, items, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
+                    fieldNode.properties = resolveFieldRef(refName(items.$ref), 'array', required, rootId, readsSource, items, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
                 }
                 else {
                     const itemType = deriveScalarType(items.type ?? 'string', items.format, packConfig.scalarTypes);
-                    fieldNode.properties = { type: itemType ?? 'string', nullable: !required, cardinality: 'many' };
+                    fieldNode.properties = { type: itemType ?? 'string', nullable: !required, collection: 'array' };
                 }
             }
             else if (fs.type === 'object' && fs.properties) {
@@ -363,34 +361,64 @@ function emitFields(schema, parentId, section, rootId, packConfig, specPath, nod
                 if (rootId) {
                     const localRef = emitSchemaNode(fs, fieldName, rootId, 'schemas', rootId, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
                     fieldNode.properties = localRef
-                        ? { $ref: localRef, nullable: !required, cardinality: 'one' }
-                        : { type: 'string', nullable: !required, cardinality: 'one' };
+                        ? { $ref: localRef, nullable: !required }
+                        : { type: 'string', nullable: !required };
                 }
                 else {
                     diagnostics.push({ severity: 'warning', file: specPath, message: `Inline object for field ${fieldId} has no endpoint context; treating as string` });
-                    fieldNode.properties = { type: 'string', nullable: !required, cardinality: 'one' };
+                    fieldNode.properties = { type: 'string', nullable: !required };
                 }
             }
             else if (fs.type === 'object' && fs.additionalProperties) {
                 // Map/dictionary: keyed collection
                 const addlRaw = fs.additionalProperties;
                 if (typeof addlRaw === 'boolean') {
-                    fieldNode.properties = { type: 'string', nullable: !required, cardinality: 'many', keyed: true };
+                    fieldNode.properties = { type: 'string', nullable: !required, collection: 'map' };
                 }
                 else {
                     const addlSchema = resolveAllOfRef(addlRaw);
                     if (isRefSchema(addlSchema)) {
-                        fieldNode.properties = resolveFieldRef(refName(addlSchema.$ref), 'many', true, required, rootId, readsSource, addlSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
+                        fieldNode.properties = resolveFieldRef(refName(addlSchema.$ref), 'map', required, rootId, readsSource, addlSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
                     }
                     else {
                         const addlObj = addlSchema;
                         if (addlObj.type === 'object') {
-                            diagnostics.push({ severity: 'warning', file: specPath, message: `Double-nested map for field ${fieldId}; value type represented as string` });
-                            fieldNode.properties = { type: 'string', nullable: !required, cardinality: 'many', keyed: true };
+                            const innerAddl = addlObj.additionalProperties;
+                            if (!innerAddl || typeof innerAddl === 'boolean') {
+                                fieldNode.properties = { type: 'string', nullable: !required, collection: 'map-of-map' };
+                            }
+                            else {
+                                const innerSchema = resolveAllOfRef(innerAddl);
+                                if (isRefSchema(innerSchema)) {
+                                    fieldNode.properties = resolveFieldRef(refName(innerSchema.$ref), 'map-of-map', required, rootId, readsSource, innerSchema, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
+                                }
+                                else {
+                                    const inner = innerSchema;
+                                    const scalarType = deriveScalarType(inner.type ?? 'string', inner.format, packConfig.scalarTypes);
+                                    if (scalarType) {
+                                        fieldNode.properties = { type: scalarType, nullable: !required, collection: 'map-of-map' };
+                                    }
+                                    else {
+                                        diagnostics.push({ severity: 'warning', file: specPath, message: `[WARN] Double-nested map for field ${fieldId}; inner value type not representable, using string` });
+                                        fieldNode.properties = { type: 'string', nullable: !required, collection: 'map-of-map' };
+                                    }
+                                }
+                            }
+                        }
+                        else if (addlObj.type === 'array') {
+                            const rawItems = addlObj.items;
+                            const items = rawItems ? resolveAllOfRef(rawItems) : undefined;
+                            if (items && isRefSchema(items)) {
+                                fieldNode.properties = resolveFieldRef(refName(items.$ref), 'map-of-array', required, rootId, readsSource, items, packConfig, specPath, nodes, edges, diagnostics, sharedSchemas, sourceSchemas, localSchemas);
+                            }
+                            else {
+                                const scalarType = items ? deriveScalarType(items.type ?? 'string', items.format, packConfig.scalarTypes) : undefined;
+                                fieldNode.properties = { type: scalarType ?? 'string', nullable: !required, collection: 'map-of-array' };
+                            }
                         }
                         else {
                             const scalarType = deriveScalarType(addlObj.type ?? 'string', addlObj.format, packConfig.scalarTypes);
-                            fieldNode.properties = { type: scalarType ?? 'string', nullable: !required, cardinality: 'many', keyed: true };
+                            fieldNode.properties = { type: scalarType ?? 'string', nullable: !required, collection: 'map' };
                         }
                     }
                 }
@@ -398,11 +426,11 @@ function emitFields(schema, parentId, section, rootId, packConfig, specPath, nod
             else {
                 const scalarType = deriveScalarType(fs.type ?? 'string', fs.format, packConfig.scalarTypes);
                 if (scalarType) {
-                    fieldNode.properties = { type: scalarType, nullable: !required, cardinality: 'one' };
+                    fieldNode.properties = { type: scalarType, nullable: !required };
                 }
                 else {
                     diagnostics.push({ severity: 'warning', file: specPath, message: `Unknown type for field ${fieldId}: ${fs.type}/${fs.format}` });
-                    fieldNode.properties = { type: 'string', nullable: !required, cardinality: 'one' };
+                    fieldNode.properties = { type: 'string', nullable: !required };
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/corum",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "repository": {
     "type": "git",

package/web/primitives.jsx

@@ -212,9 +212,8 @@ function refLocalSchemaName(ref) {
 }
 
 function fieldType(properties) {
-  const suffix = properties?.cardinality === 'many'
-    ? (properties?.keyed ? '{}' : '[]')
-    : '';
+  const c = properties?.collection;
+  const suffix = c === 'array' ? '[]' : c === 'map' ? '{}' : c === 'map-of-map' ? '{{}}' : c === 'map-of-array' ? '{[]}' : '';
   if (properties?.type) return `${properties.type}${suffix}`;
   const ref = properties?.['$ref'];
   if (ref) return `${refName(ref)}${suffix}`;
@@ -228,7 +227,7 @@ function fieldRequirement(properties) {
 }
 
 function fieldCardinality(properties) {
-  return properties?.cardinality ?? '-';
+  return properties?.collection ?? 'one';
 }
 
 function fieldDetails(properties) {
@@ -336,7 +335,8 @@ function SchemaFieldRows({ schemaName, model, prefix = '', depth = 0, visited =
         const canExpand = localRef !== null && model.schemasByName.has(localRef) && !visited.has(localRef);
         const childSchemaNode = canExpand ? model.schemasByName.get(localRef) : null;
         const childGhostFields = childSchemaNode ? overlayFieldsForSchema(overlayFields, childSchemaNode.id) : [];
-        const childPrefix = `${prefix}${name}${field.properties?.cardinality === 'many' ? '[].' : '.'}`;
+        const c = field.properties?.collection;
+        const childPrefix = `${prefix}${name}${c === 'map-of-map' || c === 'map-of-array' ? '[][].' : c === 'array' || c === 'map' ? '[].' : '.'}`;
         const nextVisited = new Set(visited);
         nextVisited.add(schemaName);
         const links = edges.filter(e =>
@@ -552,7 +552,7 @@ function SchemaCard({ title, nodes, allNodes, edges, anchorIdForNode, overlayFie
                   <div />
                   <div className="label-xs">Name</div>
                   <div className="label-xs">Type</div>
-                  <div className="label-xs">Cardinality</div>
+                  <div className="label-xs">Collection</div>
                   <div className="label-xs">Req</div>
                   <div className="label-xs">State</div>
                   <div className="label-xs">Links</div>