@nyrra/prismantix-cli 0.0.4-next.23 → 0.0.4-next.24

package/dist/foundry-import/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/foundry-import/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGxE,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,oBAAoB,EAAE,GACjC,eAAe,CAejB"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/foundry-import/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,oBAAoB,EAYpB,eAAe,EACf,MAAM,YAAY,CAAC;AAOpB,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,oBAAoB,EAAE,GACjC,eAAe,CAkBjB"}

package/dist/foundry-import/parse.js

@@ -1,8 +1,14 @@
 import { arrayField, isRecord } from "./utils.js";
+const baseTypeFields = ["baseType", "dataType", "type"];
+const dataTypeFields = ["dataType", "type"];
+const interfaceTypeFields = ["type", "dataType", "fieldType"];
 export function parseFoundryV2Export(input, diagnostics) {
     if (!isRecord(input)) {
         throw new Error("Expected a JSON object.");
     }
+    if (isFoundryFullMetadataExport(input)) {
+        return parseFoundryFullMetadataExport(input, diagnostics);
+    }
     const version = typeof input.version === "number" ? input.version : 0;
     addVersionDiagnostic(version, input.version, diagnostics);
     return {
@@ -15,6 +21,445 @@ export function parseFoundryV2Export(input, diagnostics) {
         version,
     };
 }
+function isFoundryFullMetadataExport(input) {
+    const objectTypes = input.objectTypes;
+    return (isRecord(objectTypes) &&
+        Object.values(objectTypes).some((value) => isRecord(value) && isRecord(value.objectType)));
+}
+function parseFoundryFullMetadataExport(input, diagnostics) {
+    const objectTypes = recordField(input, "objectTypes");
+    return {
+        actionTypes: recordValues(input, "actionTypes").map(fullMetadataActionType),
+        interfaces: recordValues(input, "interfaceTypes").map(fullMetadataInterface),
+        objectTypes: Object.values(objectTypes).map(fullMetadataObjectType),
+        relations: fullMetadataRelations(objectTypes, diagnostics),
+        sharedProperties: recordValues(input, "sharedPropertyTypes").map(fullMetadataSharedProperty),
+        typeGroups: arrayField(input, "typeGroups"),
+        version: 2,
+    };
+}
+function fullMetadataObjectType(value) {
+    const wrapper = isRecord(value) ? value : {};
+    const objectType = isRecord(wrapper.objectType)
+        ? wrapper.objectType
+        : wrapper;
+    return {
+        aliases: stringArray(objectType.aliases),
+        apiName: stringField(objectType, "apiName"),
+        datasources: arrayField(objectType, "datasources"),
+        displayMetadata: fullMetadataDisplayMetadata(objectType),
+        interfaces: fullMetadataObjectInterfaces(wrapper),
+        primaryKeys: fullMetadataPrimaryKeys(objectType),
+        properties: recordEntries(objectType, "properties").map(([key, property]) => fullMetadataProperty(key, property)),
+        rid: stringField(objectType, "rid"),
+        status: fullMetadataStatus(objectType.status),
+        titlePropertyId: fullMetadataTitleProperty(objectType),
+        typeGroups: stringArray(objectType.typeGroups),
+    };
+}
+function fullMetadataPrimaryKeys(objectType) {
+    const primaryKey = stringField(objectType, "primaryKey");
+    return primaryKey ? [primaryKey] : stringArray(objectType.primaryKeys);
+}
+function fullMetadataTitleProperty(objectType) {
+    return firstStringField(objectType, ["titleProperty", "titlePropertyId"]);
+}
+function fullMetadataObjectInterfaces(wrapper) {
+    const implementsInterfaces = stringArray(wrapper.implementsInterfaces);
+    if (implementsInterfaces.length > 0) {
+        return implementsInterfaces;
+    }
+    const implementsInterfaces2 = wrapper.implementsInterfaces2;
+    return isRecord(implementsInterfaces2)
+        ? Object.keys(implementsInterfaces2)
+        : [];
+}
+function fullMetadataProperty(apiName, value) {
+    const property = isRecord(value) ? value : {};
+    return {
+        apiName: stringFieldWithFallback(property, "apiName", apiName),
+        baseFormatter: property.baseFormatter,
+        baseType: fullMetadataBaseType(firstPresentValue(property, baseTypeFields)),
+        dataConstraints: dataConstraints(property),
+        displayMetadata: fullMetadataDisplayMetadata(property),
+        id: stringFieldWithFallback(property, "id", apiName),
+        indexedForSearch: booleanField(property, "indexedForSearch"),
+        renderHints: renderHints(property),
+        rid: stringField(property, "rid"),
+        source: recordOrUndefined(property.source),
+        status: fullMetadataStatus(property.status),
+        typeClasses: arrayField(property, "typeClasses"),
+        valueType: fullMetadataValueType(property),
+    };
+}
+function fullMetadataActionType(value) {
+    const action = isRecord(value) ? value : {};
+    return {
+        actionTypeLogic: {
+            logic: {
+                rules: arrayField(action, "operations").map((operation) => ({ type: operation.type })),
+            },
+        },
+        metadata: {
+            apiName: stringField(action, "apiName"),
+            displayMetadata: fullMetadataDisplayMetadata(action),
+            formContentInOrder: recordEntries(action, "parameters").map(([id, parameter]) => ({
+                parameter: fullMetadataActionParameter(id, parameter),
+                type: "parameter",
+            })),
+            rid: stringField(action, "rid"),
+            status: fullMetadataStatus(action.status),
+        },
+    };
+}
+function fullMetadataActionParameter(id, value) {
+    const parameter = isRecord(value) ? value : {};
+    return {
+        displayMetadata: fullMetadataDisplayMetadata(parameter),
+        id,
+        type: fullMetadataBaseType(firstPresentValue(parameter, dataTypeFields)),
+    };
+}
+function fullMetadataInterface(value) {
+    const interfaceType = isRecord(value) ? value : {};
+    return {
+        apiName: stringField(interfaceType, "apiName"),
+        displayMetadata: fullMetadataDisplayMetadata(interfaceType),
+        extendsInterfaces: stringArray(interfaceType.extendsInterfaces),
+        links: recordOrArrayValues(interfaceType.links),
+        properties: recordOrArrayValues(interfaceType.properties).map(fullMetadataInterfaceProperty),
+        rid: stringField(interfaceType, "rid"),
+        searchable: booleanField(interfaceType, "searchable"),
+        status: fullMetadataStatus(interfaceType.status),
+    };
+}
+function fullMetadataInterfaceProperty(value) {
+    const property = isRecord(value) ? value : {};
+    return {
+        displayName: stringField(property, "displayName"),
+        isSharedProperty: booleanField(property, "isSharedProperty"),
+        required: firstBooleanField(property, [
+            "required",
+            "requireImplementation",
+        ]),
+        sharedPropertyRid: stringField(property, "sharedPropertyRid"),
+        type: fullMetadataBaseType(firstPresentValue(property, interfaceTypeFields)),
+    };
+}
+function fullMetadataSharedProperty(value) {
+    const property = isRecord(value) ? value : {};
+    return {
+        aliases: stringArray(property.aliases),
+        apiName: stringField(property, "apiName"),
+        baseType: fullMetadataBaseType(firstPresentValue(property, baseTypeFields)),
+        dataConstraints: dataConstraints(property),
+        displayMetadata: fullMetadataDisplayMetadata(property),
+        indexedForSearch: booleanField(property, "indexedForSearch"),
+        renderHints: renderHints(property),
+        rid: stringField(property, "rid"),
+        valueType: fullMetadataValueType(property),
+    };
+}
+function fullMetadataRelations(objectTypes, diagnostics) {
+    const groups = fullMetadataLinkGroups(objectTypes);
+    return [...groups.entries()].flatMap(([relationRid, links], relationIndex) => fullMetadataRelation(relationRid, links, relationIndex, diagnostics));
+}
+function fullMetadataLinkGroups(objectTypes) {
+    const groups = new Map();
+    for (const value of Object.values(objectTypes)) {
+        addFullMetadataObjectLinks(groups, value);
+    }
+    return groups;
+}
+function addFullMetadataObjectLinks(groups, value) {
+    const wrapper = isRecord(value) ? value : {};
+    const context = fullMetadataLinkContext(wrapper);
+    if (!context) {
+        return;
+    }
+    for (const link of arrayField(wrapper, "linkTypes")) {
+        addFullMetadataLink(groups, context, link);
+    }
+}
+function addFullMetadataLink(groups, context, value) {
+    const linkRecord = isRecord(value) ? value : {};
+    const relationRid = fullMetadataRelationRid(context.sourceApiName, linkRecord);
+    const group = groups.get(relationRid) ?? [];
+    group.push({ link: linkRecord, ...context });
+    groups.set(relationRid, group);
+}
+function fullMetadataLinkContext(wrapper) {
+    const objectType = fullMetadataWrappedObjectType(wrapper);
+    const sourceApiName = stringField(objectType, "apiName");
+    const sourceRid = stringField(objectType, "rid");
+    return sourceApiName && sourceRid ? { sourceApiName, sourceRid } : undefined;
+}
+function fullMetadataRelationRid(sourceApiName, link) {
+    return (stringField(link, "linkTypeRid") ??
+        `${sourceApiName}:${stringFieldWithFallback(link, "apiName", "link")}`);
+}
+function fullMetadataRelation(relationRid, links, relationIndex, diagnostics) {
+    if (links.length !== 2) {
+        diagnostics.push({
+            code: "skipped.fullMetadataLinkGroup",
+            message: `Foundry full-metadata link group ${relationRid} has ${links.length} sides; expected 2.`,
+            path: `$.objectTypes.*.linkTypes[${relationIndex}]`,
+            severity: "warning",
+        });
+        return [];
+    }
+    const foreignKeySide = links.find((link) => Boolean(stringField(link.link, "foreignKeyPropertyApiName")));
+    if (foreignKeySide) {
+        return fullMetadataOneToManyRelation(relationRid, links, foreignKeySide);
+    }
+    return [fullMetadataManyToManyRelation(relationRid, linkPair(links))];
+}
+function fullMetadataManyToManyRelation(relationRid, [a, b]) {
+    return {
+        definition: {
+            manyToMany: {
+                objectTypeAToBLinkMetadata: fullMetadataLinkMetadata(a.link),
+                objectTypeBToALinkMetadata: fullMetadataLinkMetadata(b.link),
+                objectTypeRidA: a.sourceRid,
+                objectTypeRidB: b.sourceRid,
+            },
+            type: "manyToMany",
+        },
+        id: relationRid,
+        rid: relationRid,
+        status: fullMetadataStatus(firstPresentValueFromList([a.link, b.link], "status")),
+    };
+}
+function fullMetadataOneToManyRelation(relationRid, links, foreignKeySide) {
+    const oneSide = links.find((link) => link !== foreignKeySide);
+    if (!oneSide) {
+        return [];
+    }
+    return [
+        {
+            definition: {
+                oneToMany: {
+                    cardinalityHint: stringField(oneSide.link, "cardinality") === "ONE"
+                        ? "ONE_TO_ONE"
+                        : "ONE_TO_MANY",
+                    manySideForeignKeyPropertyId: stringField(foreignKeySide.link, "foreignKeyPropertyApiName"),
+                    manyToOneLinkMetadata: fullMetadataLinkMetadata(foreignKeySide.link),
+                    objectTypeRidManySide: foreignKeySide.sourceRid,
+                    objectTypeRidOneSide: oneSide.sourceRid,
+                    oneToManyLinkMetadata: fullMetadataLinkMetadata(oneSide.link),
+                },
+                type: "oneToMany",
+            },
+            id: relationRid,
+            rid: relationRid,
+            status: fullMetadataStatus(foreignKeySide.link.status ?? oneSide.link.status),
+        },
+    ];
+}
+function fullMetadataLinkMetadata(link) {
+    return {
+        apiName: stringField(link, "apiName"),
+        displayMetadata: fullMetadataDisplayMetadata(link),
+        typeClasses: arrayField(link, "typeClasses"),
+    };
+}
+function fullMetadataWrappedObjectType(value) {
+    const wrapper = isRecord(value) ? value : {};
+    return isRecord(wrapper.objectType) ? wrapper.objectType : wrapper;
+}
+function fullMetadataBaseType(value) {
+    const record = recordOrUndefined(value);
+    return record ? fullMetadataBaseTypeFromRecord(record) : undefined;
+}
+function fullMetadataBaseTypeFromRecord(value) {
+    const type = stringField(value, "type");
+    return type
+        ? typedFullMetadataBaseType(value, type)
+        : value;
+}
+function typedFullMetadataBaseType(value, type) {
+    const normalizedType = normalizeFullMetadataType(type);
+    return {
+        ...value,
+        ...fullMetadataBaseTypeExtras(value, normalizedType),
+        type: normalizedType,
+    };
+}
+function fullMetadataBaseTypeExtras(value, type) {
+    const extras = {
+        ARRAY: () => ({ subType: fullMetadataBaseType(value.subType) }),
+        STRUCT: () => ({
+            structFields: recordOrArrayValues(value.fields).map((field) => fullMetadataStructField(field)),
+        }),
+    };
+    return extras[type]?.() ?? {};
+}
+function fullMetadataStructField(value) {
+    const field = isRecord(value) ? value : {};
+    return {
+        apiName: stringField(field, "apiName") ?? stringField(field, "name"),
+        displayMetadata: fullMetadataDisplayMetadata(field),
+        fieldType: fullMetadataBaseType(field.fieldType ?? field.dataType),
+    };
+}
+function normalizeFullMetadataType(type) {
+    const typeMap = {
+        array: "ARRAY",
+        attachment: "ATTACHMENT",
+        boolean: "BOOLEAN",
+        date: "DATE",
+        double: "DOUBLE",
+        geohash: "GEOHASH",
+        geopoint: "GEOHASH",
+        geoshape: "GEOSHAPE",
+        integer: "INTEGER",
+        long: "LONG",
+        marking: "MARKING",
+        mediaReference: "MEDIA_REFERENCE",
+        string: "STRING",
+        struct: "STRUCT",
+        timestamp: "TIMESTAMP",
+        vector: "VECTOR",
+    };
+    return typeMap[type] ?? type;
+}
+function fullMetadataStatus(value) {
+    const type = fullMetadataStatusType(value);
+    return type
+        ? { ...fullMetadataStatusRecord(value), type: type.toLowerCase() }
+        : undefined;
+}
+function fullMetadataStatusRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function fullMetadataStatusType(value) {
+    return typeof value === "string"
+        ? nonEmptyString(value)
+        : stringField(fullMetadataStatusRecord(value), "type");
+}
+function fullMetadataDisplayMetadata(record) {
+    const nested = recordOrUndefined(record.displayMetadata);
+    return nested ? nested : displayMetadataFromTopLevelFields(record);
+}
+function displayMetadataFromTopLevelFields(record) {
+    const displayMetadata = {
+        description: nullableStringField(record, "description"),
+        displayName: nullableStringField(record, "displayName"),
+        groupDisplayName: nullableStringField(record, "groupDisplayName"),
+        icon: definedValue(record.icon),
+        pluralDisplayName: nullableStringField(record, "pluralDisplayName"),
+        visibility: nullableStringField(record, "visibility"),
+    };
+    const compact = compactRecord(displayMetadata);
+    return Object.keys(compact).length > 0
+        ? compact
+        : undefined;
+}
+function linkPair(links) {
+    return [links[0], links[1]];
+}
+function fullMetadataValueType(record) {
+    const explicit = record.valueType;
+    return explicit === undefined ? valueTypeReference(record) : explicit;
+}
+function firstPresentValue(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstPresentValueFromList(records, key) {
+    for (const record of records) {
+        const value = record[key];
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstStringField(record, keys) {
+    for (const key of keys) {
+        const value = stringField(record, key);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstBooleanField(record, keys) {
+    for (const key of keys) {
+        const value = booleanField(record, key);
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function stringFieldWithFallback(record, key, fallback) {
+    return stringField(record, key) ?? fallback;
+}
+function recordOrUndefined(value) {
+    return isRecord(value) ? value : undefined;
+}
+function nonEmptyString(value) {
+    return value === "" ? undefined : value;
+}
+function nullableStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" || value === null ? value : undefined;
+}
+function definedValue(value) {
+    return value === undefined ? undefined : value;
+}
+function compactRecord(record) {
+    return Object.fromEntries(Object.entries(record).filter((entry) => entry[1] !== undefined));
+}
+function dataConstraints(record) {
+    return isRecord(record.dataConstraints) ? record.dataConstraints : undefined;
+}
+function valueTypeReference(record) {
+    const valueTypeApiName = stringField(record, "valueTypeApiName");
+    return valueTypeApiName ? { apiName: valueTypeApiName } : undefined;
+}
+function renderHints(record) {
+    const explicit = stringArray(record.renderHints);
+    if (explicit.length > 0) {
+        return explicit;
+    }
+    return arrayField(record, "typeClasses").flatMap((typeClass) => typeClass.kind === "render_hint" && typeClass.name ? [typeClass.name] : []);
+}
+function recordField(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : {};
+}
+function recordValues(record, key) {
+    return Object.values(recordField(record, key));
+}
+function recordEntries(record, key) {
+    return Object.entries(recordField(record, key));
+}
+function recordOrArrayValues(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return isRecord(value) ? Object.values(value) : [];
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+function booleanField(record, key) {
+    const value = record[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
 function addVersionDiagnostic(version, rawVersion, diagnostics) {
     if (version === 2) {
         return;

package/oclif.manifest.json

@@ -184,5 +184,5 @@
       ]
     }
   },
-  "version": "0.0.4-next.23"
+  "version": "0.0.4-next.24"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nyrra/prismantix-cli",
   "description": "PrismantiX API client CLI.",
-  "version": "0.0.4-next.23",
+  "version": "0.0.4-next.24",
   "author": "NYRRA Inc.",
   "bin": {
     "prismantix-cli": "bin/run.js"