@osdk/generator-converters.ontologyir 2.3.0-beta.5

package/build/cjs/index.cjs

@@ -0,0 +1,774 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/OntologyIrToFullMetadataConverter.ts
+var OntologyIrToFullMetadataConverter = class {
+  /**
+   * Main entry point - converts IR to full metadata
+   */
+  static getFullMetadataFromIr(ir) {
+    const interfaceTypes = this.getOsdkInterfaceTypes(Object.values(ir.interfaceTypes));
+    const sharedPropertyTypes = this.getOsdkSharedPropertyTypes(Object.values(ir.sharedPropertyTypes));
+    const objectTypes = this.getOsdkObjectTypes(Object.values(ir.objectTypes), Object.values(ir.linkTypes));
+    const actionTypes = this.getOsdkActionTypes(Object.values(ir.actionTypes));
+    return {
+      interfaceTypes,
+      sharedPropertyTypes,
+      objectTypes,
+      queryTypes: {},
+      actionTypes,
+      ontology: {
+        apiName: "ontology",
+        rid: `ri.00000`,
+        displayName: "ontology",
+        description: ""
+      }
+    };
+  }
+  /**
+   * Convert IR object types to OSDK format
+   */
+  static getOsdkObjectTypes(objects, links) {
+    const linkMappings = this.getLinkMappings(links);
+    const result = {};
+    for (const fullObject of objects) {
+      const object = fullObject.objectType;
+      const icon = object.displayMetadata.icon;
+      if (icon.type !== "blueprint") {
+        throw new Error("Only blueprint icons are supported");
+      }
+      if (object.primaryKeys.length !== 1) {
+        throw new Error("Object must have exactly 1 primary key");
+      }
+      const primaryKey = object.primaryKeys[0];
+      const titleProperty = object.titlePropertyTypeRid;
+      const properties = {};
+      for (const [propKey, prop] of Object.entries(object.propertyTypes)) {
+        const visibility = prop.displayMetadata.visibility;
+        let visibilityEnum = "NORMAL";
+        if (!visibility) {
+          visibilityEnum = "NORMAL";
+        } else {
+          switch (visibility) {
+            case "PROMINENT":
+              visibilityEnum = "PROMINENT";
+              break;
+            case "NORMAL":
+              visibilityEnum = "NORMAL";
+              break;
+            case "HIDDEN":
+              visibilityEnum = "HIDDEN";
+              break;
+            default:
+              visibilityEnum = "NORMAL";
+          }
+        }
+        const dataType = this.getOsdkPropertyType(prop.type);
+        if (dataType) {
+          const status = {
+            type: prop.status.type,
+            ...prop.status[prop.status.type] ?? {}
+          };
+          properties[propKey] = {
+            displayName: prop.displayMetadata.displayName,
+            rid: `ri.${object.apiName}.${propKey}`,
+            status,
+            description: prop.displayMetadata.description ?? void 0,
+            visibility: visibilityEnum,
+            dataType
+          };
+        }
+      }
+      const objectTypeV2 = {
+        apiName: object.apiName,
+        description: object.displayMetadata.description ?? void 0,
+        displayName: object.displayMetadata.displayName,
+        pluralDisplayName: "",
+        // Not available in IR
+        primaryKey,
+        titleProperty,
+        icon: {
+          type: "blueprint",
+          color: icon.blueprint.color,
+          name: icon.blueprint.locator
+        },
+        status: this.convertObjectTypeStatus(object.status),
+        properties,
+        rid: `ri.${object.apiName}`
+      };
+      const sharedPropertyTypeMappings = {};
+      const implementsInterfaces2 = {};
+      for (const ii of object.implementsInterfaces2) {
+        const interfaceApiName = ii.interfaceTypeApiName;
+        const propertyMappings = {};
+        for (const [sharedPropKey, propMapping] of Object.entries(ii.properties)) {
+          const propertyApiName = propMapping.propertyTypeRid;
+          propertyMappings[sharedPropKey] = propertyApiName;
+          sharedPropertyTypeMappings[sharedPropKey] = propertyApiName;
+        }
+        implementsInterfaces2[interfaceApiName] = {
+          properties: propertyMappings
+        };
+      }
+      const objectApiName = object.apiName;
+      result[objectApiName] = {
+        objectType: objectTypeV2,
+        implementsInterfaces: [],
+        // Empty for now - legacy field
+        implementsInterfaces2,
+        sharedPropertyTypeMapping: sharedPropertyTypeMappings,
+        linkTypes: linkMappings[objectApiName] || []
+      };
+    }
+    return result;
+  }
+  /**
+   * Create link mappings from IR link types
+   */
+  static getLinkMappings(links) {
+    const result = {};
+    for (const link of links) {
+      const linkType = link.linkType;
+      const linkApiName = linkType.id;
+      const linkStatus = this.convertLinkTypeStatus(linkType.status);
+      let mappings;
+      switch (linkType.definition.type) {
+        case "manyToMany": {
+          const linkDef = linkType.definition.manyToMany;
+          const sideA = {
+            apiName: linkApiName,
+            displayName: linkApiName,
+            cardinality: "MANY",
+            objectTypeApiName: linkDef.objectTypeRidA,
+            linkTypeRid: `ri.${linkDef.objectTypeRidA}.${linkApiName}.${linkDef.objectTypeRidB}`,
+            status: linkStatus
+          };
+          const sideB = {
+            ...sideA,
+            objectTypeApiName: linkDef.objectTypeRidB
+          };
+          mappings = {
+            [linkDef.objectTypeRidA]: sideA,
+            [linkDef.objectTypeRidB]: sideB
+          };
+          break;
+        }
+        case "oneToMany": {
+          const linkDef = linkType.definition.oneToMany;
+          const sideOne = {
+            apiName: linkApiName,
+            displayName: linkApiName,
+            objectTypeApiName: linkDef.objectTypeRidOneSide,
+            cardinality: "ONE",
+            linkTypeRid: `ri.${linkDef.objectTypeRidOneSide}.${linkApiName}.${linkDef.objectTypeRidManySide}`,
+            status: linkStatus
+          };
+          const sideMany = {
+            ...sideOne,
+            cardinality: "MANY",
+            objectTypeApiName: linkDef.objectTypeRidManySide
+          };
+          mappings = {
+            [linkDef.objectTypeRidOneSide]: sideOne,
+            [linkDef.objectTypeRidManySide]: sideMany
+          };
+          break;
+        }
+        default:
+          throw new Error("Unknown link definition type");
+      }
+      for (const [objectTypeApiName, linkSide] of Object.entries(mappings)) {
+        if (!result[objectTypeApiName]) {
+          result[objectTypeApiName] = [];
+        }
+        result[objectTypeApiName].push(linkSide);
+      }
+    }
+    return result;
+  }
+  /**
+   * Convert IR action types to OSDK format
+   */
+  static getOsdkActionTypes(actions) {
+    const result = {};
+    for (const action of actions) {
+      const metadata = action.actionType.metadata;
+      const actionType = {
+        rid: `ri.action.${metadata.apiName}`,
+        apiName: metadata.apiName,
+        displayName: metadata.displayMetadata.displayName,
+        description: metadata.displayMetadata.description,
+        parameters: this.getOsdkActionParameters(action),
+        operations: this.getOsdkActionOperations(action),
+        status: this.convertActionTypeStatus(metadata.status)
+      };
+      result[actionType.apiName] = actionType;
+    }
+    return result;
+  }
+  /**
+   * Convert action operations from IR
+   */
+  static getOsdkActionOperations(action) {
+    return action.actionType.actionTypeLogic.logic.rules.map((irLogic) => {
+      switch (irLogic.type) {
+        case "addInterfaceRule": {
+          const r = irLogic.addInterfaceRule;
+          return {
+            type: "createInterfaceObject",
+            interfaceTypeApiName: r.interfaceApiName
+          };
+        }
+        case "addLinkRule":
+          throw new Error("Add link rule not supported");
+        case "addObjectRule": {
+          const r = irLogic.addObjectRule;
+          return {
+            type: "createObject",
+            objectTypeApiName: r.objectTypeId
+          };
+        }
+        case "addOrModifyObjectRuleV2": {
+          const r = irLogic.addOrModifyObjectRuleV2;
+          return {
+            type: "modifyObject",
+            objectTypeApiName: r.objectToModify
+          };
+        }
+        case "deleteLinkRule":
+          throw new Error("Delete link rule not supported");
+        case "deleteObjectRule": {
+          const r = irLogic.deleteObjectRule;
+          return {
+            type: "deleteObject",
+            objectTypeApiName: r.objectToDelete
+          };
+        }
+        case "modifyInterfaceRule": {
+          const r = irLogic.modifyInterfaceRule;
+          const parameter = action.actionType.metadata.parameters[r.interfaceObjectToModifyParameter];
+          if (!parameter) {
+            throw new Error("Could not find interface type api name");
+          }
+          let interfaceTypeApiName = null;
+          switch (parameter.type.type) {
+            case "interfaceReference":
+              interfaceTypeApiName = parameter.type.interfaceReference.interfaceTypeRid;
+              break;
+            case "interfaceReferenceList":
+              interfaceTypeApiName = parameter.type.interfaceReferenceList.interfaceTypeRid;
+              break;
+            default:
+              interfaceTypeApiName = null;
+          }
+          if (!interfaceTypeApiName) {
+            throw new Error("Could not find interface type api name");
+          }
+          return {
+            type: "modifyInterfaceObject",
+            interfaceTypeApiName
+          };
+        }
+        case "modifyObjectRule": {
+          const r = irLogic.modifyObjectRule;
+          return {
+            type: "modifyObject",
+            objectTypeApiName: r.objectToModify
+          };
+        }
+        default:
+          throw new Error("Unknown logic rule type");
+      }
+    });
+  }
+  /**
+   * Convert action parameters from IR
+   */
+  static getOsdkActionParameters(action) {
+    const result = {};
+    for (const [paramKey, irParameter] of Object.entries(action.actionType.metadata.parameters)) {
+      let dataType;
+      switch (irParameter.type.type) {
+        case "attachment":
+          dataType = {
+            type: "attachment"
+          };
+          break;
+        case "attachmentList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "attachment"
+            }
+          };
+          break;
+        case "boolean":
+          dataType = {
+            type: "boolean"
+          };
+          break;
+        case "booleanList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "boolean"
+            }
+          };
+          break;
+        case "date":
+          dataType = {
+            type: "date"
+          };
+          break;
+        case "dateList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "date"
+            }
+          };
+          break;
+        case "decimal":
+          throw new Error("Decimal type not supported");
+        case "decimalList":
+          throw new Error("Decimal list type not supported");
+        case "double":
+          dataType = {
+            type: "double"
+          };
+          break;
+        case "doubleList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "double"
+            }
+          };
+          break;
+        case "geohash":
+          dataType = {
+            type: "geohash"
+          };
+          break;
+        case "geohashList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "geohash"
+            }
+          };
+          break;
+        case "geoshape":
+          dataType = {
+            type: "geoshape"
+          };
+          break;
+        case "geoshapeList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "geoshape"
+            }
+          };
+          break;
+        case "geotimeSeriesReference":
+          throw new Error("Geotime series reference type not supported");
+        case "geotimeSeriesReferenceList":
+          throw new Error("Geotime series reference list type not supported");
+        case "integer":
+          dataType = {
+            type: "integer"
+          };
+          break;
+        case "integerList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "integer"
+            }
+          };
+          break;
+        case "interfaceReference":
+          throw new Error("Interface reference type not supported");
+        case "interfaceReferenceList":
+          throw new Error("Interface reference list type not supported");
+        case "long":
+          dataType = {
+            type: "long"
+          };
+          break;
+        case "longList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "long"
+            }
+          };
+          break;
+        case "marking":
+          dataType = {
+            type: "marking"
+          };
+          break;
+        case "markingList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "marking"
+            }
+          };
+          break;
+        case "mediaReference":
+          dataType = {
+            type: "mediaReference"
+          };
+          break;
+        case "mediaReferenceList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "mediaReference"
+            }
+          };
+          break;
+        case "objectReference": {
+          const t = irParameter.type.objectReference;
+          dataType = {
+            type: "object",
+            objectTypeApiName: t.objectTypeId,
+            objectApiName: t.objectTypeId
+          };
+          break;
+        }
+        case "objectReferenceList": {
+          const t = irParameter.type.objectReferenceList;
+          dataType = {
+            type: "array",
+            subType: {
+              type: "object",
+              objectTypeApiName: t.objectTypeId,
+              objectApiName: t.objectTypeId
+            }
+          };
+          break;
+        }
+        case "objectSetRid":
+          dataType = {
+            type: "objectSet"
+          };
+          break;
+        case "objectTypeReference":
+          dataType = {
+            type: "objectType"
+          };
+          break;
+        case "string":
+          dataType = {
+            type: "string"
+          };
+          break;
+        case "stringList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "string"
+            }
+          };
+          break;
+        case "struct":
+          throw new Error("Struct type not supported (lazy implementation)");
+        case "structList":
+          throw new Error("Struct list type not supported");
+        case "timeSeriesReference":
+          throw new Error("Time series reference type not supported");
+        case "timestamp":
+          dataType = {
+            type: "timestamp"
+          };
+          break;
+        case "timestampList":
+          dataType = {
+            type: "array",
+            subType: {
+              type: "timestamp"
+            }
+          };
+          break;
+        default:
+          throw new Error("Unknown parameter type");
+      }
+      result[paramKey] = {
+        displayName: irParameter.displayMetadata.displayName,
+        description: irParameter.displayMetadata.description,
+        required: true,
+        dataType
+      };
+    }
+    return result;
+  }
+  /**
+   * Convert interface types from IR
+   */
+  static getOsdkInterfaceTypes(interfaces) {
+    const result = {};
+    for (const interfaceData of interfaces) {
+      const interfaceType = interfaceData.interfaceType;
+      const properties = {};
+      for (const [propKey, propValue] of Object.entries(interfaceType.propertiesV2)) {
+        const spt = propValue.sharedPropertyType;
+        const dataType = this.getOsdkPropertyType(spt.type);
+        if (dataType) {
+          properties[propKey] = {
+            rid: `ri.interface.${interfaceType.apiName}.${spt.apiName}`,
+            apiName: spt.apiName,
+            displayName: spt.displayMetadata.displayName,
+            description: spt.displayMetadata.description ?? void 0,
+            dataType,
+            required: false
+            // Default to false for now - this should come from IR if available
+          };
+        }
+      }
+      const result_interfaceType = {
+        apiName: interfaceType.apiName,
+        rid: `ri.interface.${interfaceType.apiName}`,
+        properties,
+        allProperties: properties,
+        // Same as properties for now
+        extendsInterfaces: interfaceType.extendsInterfaces.map((val) => val),
+        allExtendsInterfaces: interfaceType.extendsInterfaces.map((val) => val),
+        // Same as extendsInterfaces for now
+        implementedByObjectTypes: [],
+        // Empty for now
+        displayName: interfaceType.displayMetadata.displayName,
+        description: interfaceType.displayMetadata.description ?? void 0,
+        links: this.getOsdkInterfaceLinkTypes(interfaceType.links),
+        allLinks: this.getOsdkInterfaceLinkTypes(interfaceType.links)
+        // Same as links for now
+      };
+      result[result_interfaceType.apiName] = result_interfaceType;
+    }
+    return result;
+  }
+  /**
+   * Convert interface link types from IR
+   */
+  static getOsdkInterfaceLinkTypes(ilts) {
+    const result = {};
+    for (const ilt of ilts) {
+      let linkedEntityApiName;
+      switch (ilt.linkedEntityTypeId.type) {
+        case "interfaceType": {
+          const interfaceType = ilt.linkedEntityTypeId.interfaceType;
+          linkedEntityApiName = {
+            type: "interfaceTypeApiName",
+            apiName: interfaceType
+          };
+          break;
+        }
+        case "objectType":
+          throw new Error("Interface links to object types should not be possible in ontology as code yet");
+        default:
+          throw new Error("Unknown linked entity type");
+      }
+      let cardinality;
+      switch (ilt.cardinality) {
+        case "SINGLE":
+          cardinality = "ONE";
+          break;
+        case "MANY":
+          cardinality = "MANY";
+          break;
+        default:
+          throw new Error("Unknown cardinality type");
+      }
+      const interfaceLinkType = {
+        rid: `ri.interfacelink.${linkedEntityApiName.apiName}.${ilt.metadata.apiName}`,
+        apiName: ilt.metadata.apiName,
+        displayName: ilt.metadata.displayName,
+        description: ilt.metadata.description,
+        linkedEntityApiName,
+        cardinality,
+        required: ilt.required
+      };
+      result[interfaceLinkType.apiName] = interfaceLinkType;
+    }
+    return result;
+  }
+  /**
+   * Convert shared property types from IR
+   */
+  static getOsdkSharedPropertyTypes(spts) {
+    const result = {};
+    for (const spt of spts) {
+      const dataType = this.getOsdkPropertyType(spt.sharedPropertyType.type);
+      if (dataType) {
+        const sharedPropertyType = {
+          rid: `ri.spt.${spt.sharedPropertyType.apiName}`,
+          apiName: spt.sharedPropertyType.apiName,
+          displayName: spt.sharedPropertyType.displayMetadata.displayName,
+          description: spt.sharedPropertyType.displayMetadata.description ?? void 0,
+          dataType
+        };
+        result[sharedPropertyType.apiName] = sharedPropertyType;
+      } else {
+        throw new Error(`Unsupported property type '${JSON.stringify(spt.sharedPropertyType.type)}' for spt '${spt.sharedPropertyType.apiName}'`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Convert property types from IR to OSDK format
+   */
+  static getOsdkPropertyType(type) {
+    switch (type.type) {
+      case "array": {
+        const value = type.array;
+        const subType = this.getOsdkPropertyType(value.subtype);
+        return subType ? {
+          type: "array",
+          subType
+        } : null;
+      }
+      case "boolean":
+        return {
+          type: "boolean"
+        };
+      case "byte":
+        return {
+          type: "byte"
+        };
+      case "date":
+        return {
+          type: "date"
+        };
+      case "decimal":
+        return {
+          type: "decimal"
+        };
+      case "double":
+        return {
+          type: "double"
+        };
+      case "float":
+        return {
+          type: "float"
+        };
+      case "geohash":
+        return {
+          type: "geopoint"
+        };
+      case "geoshape":
+        return {
+          type: "geoshape"
+        };
+      case "integer":
+        return {
+          type: "integer"
+        };
+      case "long":
+        return {
+          type: "long"
+        };
+      case "short":
+        return {
+          type: "short"
+        };
+      case "string":
+        return {
+          type: "string"
+        };
+      case "experimentalTimeDependentV1":
+        return null;
+      case "timestamp":
+        return {
+          type: "timestamp"
+        };
+      case "attachment":
+        return {
+          type: "attachment"
+        };
+      case "marking":
+        return {
+          type: "marking"
+        };
+      case "cipherText":
+        return null;
+      case "mediaReference":
+        return null;
+      case "vector":
+        return null;
+      case "geotimeSeriesReference":
+        return null;
+      case "struct": {
+        const value = type.struct;
+        const ridBase = `ri.struct.${crypto.hash("sha256", JSON.stringify(type)).slice(0, 10)}`;
+        return {
+          type: "struct",
+          structFieldTypes: value.structFields.map((field) => {
+            const fieldDataType = this.getOsdkPropertyType(field.fieldType);
+            if (!fieldDataType) {
+              throw new Error(`Unsupported field type in struct: ${field.apiName}`);
+            }
+            return {
+              apiName: field.apiName,
+              rid: `${ridBase}.${field.apiName}`,
+              dataType: fieldDataType
+            };
+          })
+        };
+      }
+      default:
+        return null;
+    }
+  }
+  static convertObjectTypeStatus(status) {
+    switch (status.type) {
+      case "active":
+        return "ACTIVE";
+      case "deprecated":
+        return "DEPRECATED";
+      case "endorsed":
+        throw new Error("Endorsed status is not supported yet");
+      case "example":
+        throw new Error("Example status has no mapping");
+      case "experimental":
+        return "EXPERIMENTAL";
+      default:
+        throw new Error(`Unknown object type status: ${status}`);
+    }
+  }
+  static convertActionTypeStatus(status) {
+    switch (status.type) {
+      case "active":
+        return "ACTIVE";
+      case "deprecated":
+        return "DEPRECATED";
+      case "example":
+        throw new Error("Example status has no mapping");
+      case "experimental":
+        return "EXPERIMENTAL";
+      default:
+        throw new Error(`Unknown action type status: ${status}`);
+    }
+  }
+  static convertLinkTypeStatus(status) {
+    switch (status.type) {
+      case "active":
+        return "ACTIVE";
+      case "deprecated":
+        return "DEPRECATED";
+      case "example":
+        throw new Error("Example status has no mapping");
+      case "experimental":
+        return "EXPERIMENTAL";
+      default:
+        throw new Error(`Unknown link type status: ${status}`);
+    }
+  }
+};
+
+exports.OntologyIrToFullMetadataConverter = OntologyIrToFullMetadataConverter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map