@atolis-hq/corum 0.1.10 → 0.1.12

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

@@ -89,6 +89,9 @@ export function mapDocument(document, entry, packConfig) {
                 ...(operation.summary && { description: operation.summary }),
             };
             nodes.push(endpointNode);
+            const parameters = extractParameters(pathItem, operation, packConfig, entry.spec, diagnostics);
+            if (parameters)
+                endpointNode.properties.parameters = parameters;
             const requestBody = operation.requestBody;
             if (requestBody?.content) {
                 const jsonContent = requestBody.content['application/json'];
@@ -114,6 +117,56 @@ export function mapDocument(document, entry, packConfig) {
     }
     return { nodes, edges, diagnostics };
 }
+function extractParameters(pathItem, operation, packConfig, specPath, diagnostics) {
+    const pathItemParams = (pathItem.parameters ?? []);
+    const operationParams = (operation.parameters ?? []);
+    const merged = new Map();
+    for (const param of [...pathItemParams, ...operationParams]) {
+        if (isRefSchema(param))
+            continue;
+        const p = param;
+        if (p.in === 'cookie')
+            continue;
+        merged.set(p.name, p);
+    }
+    if (merged.size === 0)
+        return undefined;
+    const parameters = {};
+    for (const [name, param] of merged) {
+        const schema = param.schema;
+        if (!schema)
+            continue;
+        let type;
+        let cardinality;
+        if (schema.type === 'array') {
+            cardinality = 'many';
+            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` });
+                type = 'string';
+            }
+            else {
+                type = derived;
+            }
+        }
+        parameters[name] = {
+            location: param.in,
+            type,
+            required: param.required ?? false,
+            cardinality,
+        };
+    }
+    return Object.keys(parameters).length > 0 ? parameters : undefined;
+}
 function makeNode(template, component, specPath, id) {
     return {
         id,
@@ -186,7 +239,8 @@ function deriveComponentForSchema(name, document, entry, visited = new Set()) {
     if (visited.has(name))
         return undefined;
     visited.add(name);
-    // Direct: find an operation that references this schema
+    // Direct: collect all components whose operations reference this schema
+    const directComponents = new Set();
     for (const [urlPath, pathItem] of Object.entries(document.paths ?? {})) {
         if (!pathItem)
             continue;
@@ -196,12 +250,18 @@ function deriveComponentForSchema(name, document, entry, visited = new Set()) {
             if (!operation)
                 continue;
             if (referencesSchema(operation, name)) {
-                return entry.componentMapping.strategy === 'tag'
+                const component = entry.componentMapping.strategy === 'tag'
                     ? operation.tags?.[0]
                     : deriveComponent(urlPath, entry.componentMapping);
+                if (component)
+                    directComponents.add(component);
             }
         }
     }
+    if (directComponents.size > 1)
+        return 'shared';
+    if (directComponents.size === 1)
+        return [...directComponents][0];
     // Indirect: find another component schema that references this one and use its component
     for (const [schemaName, schema] of Object.entries(document.components?.schemas ?? {})) {
         if (schemaName === name || isRefSchema(schema))

package/dist/src/reconcile/index.js

@@ -1,4 +1,3 @@
-const ADAPTER_OWNED = new Set(['method', 'path', 'operationId', 'type', 'nullable', 'cardinality', '$ref']);
 const HUMAN_OWNED = new Set(['state', 'stability', 'notes']);
 export function diffNodes(incoming, existing, specPath) {
     const toAdd = [];
@@ -12,7 +11,7 @@ export function diffNodes(incoming, existing, specPath) {
         }
         const merged = {
             ...current,
-            properties: mergeProperties(current.properties, node.properties),
+            properties: mergeProperties(current.properties, node.properties, node.derivation),
             extractedFrom: node.extractedFrom,
             derivation: node.derivation,
             derivedBy: node.derivedBy,
@@ -32,14 +31,12 @@ export function diffNodes(incoming, existing, specPath) {
     }
     return { toAdd, toUpdate, toRemove };
 }
-function mergeProperties(current, incoming) {
-    const merged = { ...current };
-    for (const [key, value] of Object.entries(incoming)) {
-        if (ADAPTER_OWNED.has(key)) {
-            merged[key] = value;
-        }
+function mergeProperties(current, incoming, derivation) {
+    if (derivation === 'determined') {
+        const humanValues = Object.fromEntries(Object.entries(current).filter(([k]) => HUMAN_OWNED.has(k)));
+        return { ...incoming, ...humanValues };
     }
-    return merged;
+    return { ...current, ...incoming };
 }
 function nodesEqual(a, b) {
     return JSON.stringify(a) === JSON.stringify(b);

package/package.json

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

package/web/primitives.jsx

@@ -168,7 +168,11 @@ function fieldSchemaName(nodeId) {
   const fieldMarker = '.fields.';
   const schemaIdx = nodeId.indexOf(schemaMarker);
   const fieldIdx = nodeId.indexOf(fieldMarker);
-  if (schemaIdx < 0 || fieldIdx < 0) return null;
+  if (fieldIdx < 0) return null;
+  if (schemaIdx < 0) {
+    // Standalone Schema node: e.g. user.Schema.User.fields.email → 'User'
+    return nodeId.slice(0, fieldIdx).split('.').pop() ?? null;
+  }
   return nodeId.slice(schemaIdx + schemaMarker.length, fieldIdx);
 }