@osdk/maker 0.13.0-beta.9 → 0.14.0-beta.2

package/build/esm/api/defineOntology.js

@@ -16,12 +16,13 @@
 
 import * as fs from "fs";
 import * as path from "path";
-import invariant from "tiny-invariant";
-import { convertToDisplayName, isExotic } from "./defineObject.js";
-import { convertActionParameterConditionalOverride, convertActionVisibility, convertSectionConditionalOverride, getFormContentOrdering } from "./ontologyUtils.js";
-import { convertNullabilityToDataConstraint, convertType, convertValueType, convertValueTypeDataConstraints, defaultTypeClasses, getPropertyTypeName, hasRenderHints, shouldNotHaveRenderHints } from "./propertyConversionUtils.js";
-import { OntologyEntityTypeEnum } from "./types.js";
-
+import { convertActionParameters } from "../conversion/toMarketplace/convertActionParameters.js";
+import { convertActionSections } from "../conversion/toMarketplace/convertActionSections.js";
+import { convertActionValidation } from "../conversion/toMarketplace/convertActionValidation.js";
+import { convertOntologyDefinition } from "../conversion/toMarketplace/convertOntologyDefinition.js";
+import { convertOntologyToValueTypeIr } from "../conversion/toMarketplace/convertOntologyToValueTypeIr.js";
+import { getFormContentOrdering } from "../conversion/toMarketplace/getFormContentOrdering.js";
+import { OntologyEntityTypeEnum } from "./common/OntologyEntityTypeEnum.js";
 // type -> apiName -> entity
 /** @internal */
 export let ontologyDefinition;
@@ -47,7 +48,7 @@ export function updateOntology(entity) {
   }
   ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName].push(entity);
 }
-export async function defineOntology(ns, body, outputDir, dependencyFile) {
+export async function defineOntology(ns, body, outputDir, dependencyFile, randomnessKey) {
   namespace = ns;
   dependencies = {};
   ontologyDefinition = {
@@ -79,7 +80,7 @@ export async function defineOntology(ns, body, outputDir, dependencyFile) {
   if (dependencyFile) {
     writeDependencyFile(dependencyFile);
   }
-  return convertToWireOntologyIr(ontologyDefinition);
+  return convertOntologyDefinition(ontologyDefinition, randomnessKey);
 }
 export function writeStaticObjects(outputDir) {
   const codegenDir = path.resolve(outputDir, "codegen");
@@ -122,6 +123,7 @@ export function writeStaticObjects(outputDir) {
 import { wrapWithProxy, OntologyEntityTypeEnum } from '@osdk/maker';
 import type { ${entityTypeName} } from '@osdk/maker';
 
+/** @type {import('@osdk/maker').${entityTypeName}} */
 const ${entityFileNameBase}_base: ${entityTypeName} = ${ontologyTypeEnumKey === "VALUE_TYPE" ? entityJSON.slice(1, -2) : entityJSON} as unknown as ${entityTypeName};
         
 export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFileNameBase}_base);
@@ -143,146 +145,7 @@ export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFi
     });
   }
 }
-function convertOntologyToValueTypeIr(ontology) {
-  return {
-    valueTypes: convertValueTypesToIr(ontology[OntologyEntityTypeEnum.VALUE_TYPE])
-  };
-}
-function convertValueTypesToIr(valueTypes) {
-  return Object.values(valueTypes).map(definitions => ({
-    metadata: {
-      apiName: definitions[0].apiName,
-      packageNamespace: definitions[0].packageNamespace,
-      displayMetadata: definitions[0].displayMetadata,
-      status: definitions[0].status
-    },
-    // TODO(dpaquin): instead of deduping here, we should refactor the value type types from arrays to maps
-    versions: Array.from(new Map(definitions.map(definition => [definition.version, definition])).values()).map(definition => ({
-      version: definition.version,
-      baseType: definition.baseType,
-      constraints: definition.constraints,
-      exampleValues: definition.exampleValues
-    }))
-  }));
-}
-function convertToWireOntologyIr(ontology) {
-  return {
-    ontology: convertToWireBlockData(ontology),
-    importedOntology: convertToWireBlockData(importedTypes),
-    valueTypes: convertOntologyToValueTypeIr(ontology),
-    importedValueTypes: convertOntologyToValueTypeIr(importedTypes)
-  };
-}
-function convertToWireBlockData(ontology) {
-  return {
-    objectTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.OBJECT_TYPE]).map(([apiName, objectType]) => {
-      return [apiName, convertObject(objectType)];
-    })),
-    sharedPropertyTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]).map(([apiName, spt]) => [apiName, {
-      sharedPropertyType: convertSpt(spt)
-    }])),
-    interfaceTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.INTERFACE_TYPE]).map(([apiName, interfaceType]) => {
-      return [apiName, {
-        interfaceType: convertInterface(interfaceType)
-      }];
-    })),
-    linkTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.LINK_TYPE]).map(([id, link]) => {
-      return [id, convertLink(link)];
-    })),
-    actionTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.ACTION_TYPE]).map(([apiName, action]) => {
-      return [apiName, convertAction(action)];
-    })),
-    blockPermissionInformation: {
-      actionTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.ACTION_TYPE]).filter(([apiName, action]) => action.validation).map(([apiName, action]) => {
-        return [apiName, {
-          restrictionStatus: {
-            hasRolesApplied: true,
-            ontologyPackageRid: null,
-            publicProject: false
-          }
-        }];
-      })),
-      linkTypes: {},
-      objectTypes: {}
-    }
-  };
-}
-function convertObject(objectType) {
-  const propertyDatasources = (objectType.properties ?? []).flatMap(prop => extractPropertyDatasource(prop, objectType.apiName));
-  const classificationGroupMarkingNames = extractMarkingGroups(objectType.properties ?? [], "CBAC");
-  const mandatoryMarkingNames = extractMarkingGroups(objectType.properties ?? [], "MANDATORY");
-  const classificationInputGroup = classificationGroupMarkingNames.length > 0 ? classificationGroupMarkingNames.reduce((l, r) => l + "/" + r) : undefined;
-  const mandatoryInputGroup = mandatoryMarkingNames.length > 0 ? mandatoryMarkingNames.reduce((l, r) => l + "/" + r) : undefined;
-  const objectDatasource = buildDatasource(objectType.apiName, convertDatasourceDefinition(objectType, objectType.properties ?? []), classificationInputGroup, mandatoryInputGroup);
-  const implementations = objectType.implementsInterfaces ?? [];
-  return {
-    objectType: {
-      displayMetadata: {
-        description: objectType.description,
-        displayName: objectType.displayName,
-        groupDisplayName: undefined,
-        icon: {
-          type: "blueprint",
-          blueprint: objectType.icon ?? {
-            locator: "cube",
-            color: "#2D72D2"
-          }
-        },
-        pluralDisplayName: objectType.pluralDisplayName,
-        visibility: objectType.visibility ?? "NORMAL"
-      },
-      primaryKeys: [objectType.primaryKeyPropertyApiName],
-      propertyTypes: Object.fromEntries(objectType.properties?.map(val => [val.apiName, convertProperty(val)]) ?? []),
-      titlePropertyTypeRid: objectType.titlePropertyApiName,
-      apiName: objectType.apiName,
-      status: convertObjectStatus(objectType.status),
-      redacted: false,
-      implementsInterfaces2: implementations.map(impl => ({
-        interfaceTypeApiName: impl.implements.apiName,
-        linksV2: {},
-        propertiesV2: {},
-        properties: Object.fromEntries(impl.propertyMapping.map(mapping => [addNamespaceIfNone(mapping.interfaceProperty), {
-          propertyTypeRid: mapping.mapsTo
-        }]))
-      })),
-      allImplementsInterfaces: {}
-    },
-    datasources: [...propertyDatasources, objectDatasource],
-    entityMetadata: {
-      arePatchesEnabled: objectType.editsEnabled ?? false
-    }
-  };
-}
-function extractPropertyDatasource(property, objectTypeApiName) {
-  if (!isExotic(property.type)) {
-    return [];
-  }
-  const identifier = objectTypeApiName + "." + property.apiName;
-  switch (property.type) {
-    case "geotimeSeries":
-      const geotimeDefinition = {
-        type: "geotimeSeries",
-        geotimeSeries: {
-          geotimeSeriesIntegrationRid: identifier,
-          properties: [property.apiName]
-        }
-      };
-      return [buildDatasource(property.apiName, geotimeDefinition)];
-    case "mediaReference":
-      const mediaSetDefinition = {
-        type: "mediaSetView",
-        mediaSetView: {
-          assumedMarkings: [],
-          mediaSetViewLocator: identifier,
-          properties: [property.apiName]
-        }
-      };
-      return [buildDatasource(property.apiName, mediaSetDefinition)];
-    default:
-      return [];
-  }
-}
-function buildDatasource(apiName, definition, classificationMarkingGroupName, mandatoryMarkingGroupName) {
+export function buildDatasource(apiName, definition, classificationMarkingGroupName, mandatoryMarkingGroupName) {
   const needsSecurity = classificationMarkingGroupName !== undefined || mandatoryMarkingGroupName !== undefined;
   const securityConfig = needsSecurity ? {
     classificationConstraint: classificationMarkingGroupName ? {
@@ -293,7 +156,7 @@ function buildDatasource(apiName, definition, classificationMarkingGroupName, ma
     } : undefined
   } : undefined;
   return {
-    rid: "ri.ontology.main.datasource.".concat(apiName),
+    datasourceName: apiName,
     datasource: definition,
     editsConfiguration: {
       onlyAllowPrivilegedEdits: false
@@ -304,220 +167,7 @@ function buildDatasource(apiName, definition, classificationMarkingGroupName, ma
     })
   };
 }
-function convertDatasourceDefinition(objectType, properties) {
-  switch (objectType.datasource?.type) {
-    case "stream":
-      const window = objectType.datasource.retentionPeriod;
-      const retentionPolicy = window ? {
-        type: "time",
-        time: {
-          window
-        }
-      } : {
-        type: "none",
-        none: {}
-      };
-      const propertyMapping = Object.fromEntries(properties.map(prop => [prop.apiName, prop.apiName]));
-      return {
-        type: "streamV2",
-        streamV2: {
-          streamLocator: objectType.apiName,
-          propertyMapping,
-          retentionPolicy,
-          propertySecurityGroups: undefined
-        }
-      };
-    case "restrictedView":
-      return {
-        type: "restrictedViewV2",
-        restrictedViewV2: {
-          restrictedViewRid: objectType.apiName,
-          propertyMapping: buildPropertyMapping(properties)
-        }
-      };
-    case "dataset":
-    default:
-      return {
-        type: "datasetV2",
-        datasetV2: {
-          datasetRid: objectType.apiName,
-          propertyMapping: buildPropertyMapping(properties)
-        }
-      };
-  }
-}
-
-/**
- * Extracts marking group names of a specific type from object properties
- */
-function extractMarkingGroups(properties, markingType) {
-  return properties.map(prop => {
-    if (typeof prop.type === "object" && prop.type.type === "marking" && prop.type.markingType === markingType) {
-      return prop.type.markingInputGroupName;
-    }
-    return undefined;
-  }).filter(val => val !== undefined);
-}
-function buildPropertyMapping(properties) {
-  return Object.fromEntries(properties.map(prop => {
-    // editOnly
-    if (prop.editOnly) {
-      return [prop.apiName, {
-        type: "editOnly",
-        editOnly: {}
-      }];
-    }
-    // structs
-    if (typeof prop.type === "object" && prop.type?.type === "struct") {
-      const structMapping = {
-        type: "struct",
-        struct: {
-          column: prop.apiName,
-          mapping: Object.fromEntries(Object.keys(prop.type.structDefinition).map(fieldName => [fieldName, {
-            apiName: fieldName,
-            mappings: {}
-          }]))
-        }
-      };
-      return [prop.apiName, structMapping];
-    }
-    // default: column mapping
-    return [prop.apiName, {
-      type: "column",
-      column: prop.apiName
-    }];
-  }));
-}
-function convertProperty(property) {
-  const apiName = namespace + property.apiName;
-  !(!shouldNotHaveRenderHints(property.type) || !hasRenderHints(property.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant(false, `Property type ${apiName} of type '${getPropertyTypeName(property.type)}' should not have render hints`) : invariant(false) : void 0;
-  const output = {
-    apiName: property.apiName,
-    sharedPropertyTypeApiName: property.sharedPropertyType?.apiName,
-    displayMetadata: {
-      displayName: property.displayName,
-      description: property.description,
-      visibility: property.visibility ?? "NORMAL"
-    },
-    indexedForSearch: property.indexedForSearch ?? true,
-    ruleSetBinding: undefined,
-    baseFormatter: property.baseFormatter,
-    type: property.array ? {
-      type: "array",
-      array: {
-        subtype: convertType(property.type)
-      }
-    } : convertType(property.type),
-    typeClasses: property.typeClasses ?? (shouldNotHaveRenderHints(property.type) ? [] : defaultTypeClasses),
-    status: convertObjectStatus(property.status),
-    inlineAction: undefined,
-    dataConstraints: property.valueType ? convertValueTypeDataConstraints(property.valueType.constraints) : convertNullabilityToDataConstraint(property),
-    sharedPropertyTypeRid: property.sharedPropertyType?.apiName,
-    valueType: property.valueType ? convertValueType(property.valueType) : undefined
-  };
-  return output;
-}
-function convertLink(linkType) {
-  let definition;
-  let datasource = undefined;
-  if ("one" in linkType) {
-    definition = {
-      type: "oneToMany",
-      oneToMany: {
-        cardinalityHint: convertCardinality(linkType.cardinality),
-        manyToOneLinkMetadata: linkType.toMany.metadata,
-        objectTypeRidManySide: linkType.toMany.object.apiName,
-        objectTypeRidOneSide: linkType.one.object.apiName,
-        oneToManyLinkMetadata: linkType.one.metadata,
-        oneSidePrimaryKeyToManySidePropertyMapping: [{
-          from: {
-            apiName: linkType.one.object.primaryKeyPropertyApiName,
-            object: linkType.one.object.apiName
-          },
-          to: {
-            apiName: linkType.manyForeignKeyProperty,
-            object: linkType.toMany.object.apiName
-          }
-        }]
-      }
-    };
-  } else {
-    definition = {
-      type: "manyToMany",
-      manyToMany: {
-        objectTypeAToBLinkMetadata: linkType.many.metadata,
-        objectTypeBToALinkMetadata: linkType.toMany.metadata,
-        objectTypeRidA: linkType.many.object.apiName,
-        objectTypeRidB: linkType.toMany.object.apiName,
-        peeringMetadata: undefined,
-        objectTypeAPrimaryKeyPropertyMapping: [{
-          from: {
-            apiName: linkType.many.object.primaryKeyPropertyApiName,
-            object: linkType.many.object.apiName
-          },
-          to: {
-            apiName: linkType.many.object.primaryKeyPropertyApiName,
-            object: linkType.many.object.apiName
-          }
-        }],
-        objectTypeBPrimaryKeyPropertyMapping: [{
-          from: {
-            apiName: linkType.toMany.object.primaryKeyPropertyApiName,
-            object: linkType.toMany.object.apiName
-          },
-          to: {
-            apiName: linkType.toMany.object.primaryKeyPropertyApiName,
-            object: linkType.toMany.object.apiName
-          }
-        }]
-      }
-    };
-    datasource = {
-      rid: "ri.ontology.main.datasource.link-".concat(linkType.apiName),
-      datasource: {
-        type: "dataset",
-        dataset: {
-          datasetRid: "link-".concat(linkType.apiName),
-          writebackDatasetRid: undefined,
-          objectTypeAPrimaryKeyMapping: [{
-            property: {
-              apiName: linkType.many.object.primaryKeyPropertyApiName,
-              object: linkType.many.object.apiName
-            },
-            column: linkType.many.object.primaryKeyPropertyApiName
-          }],
-          objectTypeBPrimaryKeyMapping: [{
-            property: {
-              apiName: linkType.toMany.object.primaryKeyPropertyApiName,
-              object: linkType.toMany.object.apiName
-            },
-            column: linkType.toMany.object.primaryKeyPropertyApiName
-          }]
-        }
-      },
-      editsConfiguration: {
-        onlyAllowPrivilegedEdits: false
-      },
-      redacted: linkType.redacted
-    };
-  }
-  return {
-    linkType: {
-      definition: definition,
-      id: cleanAndValidateLinkTypeId(linkType.apiName),
-      status: linkType.status ?? {
-        type: "active",
-        active: {}
-      },
-      redacted: linkType.redacted ?? false
-    },
-    datasources: datasource !== undefined ? [datasource] : [],
-    entityMetadata: {
-      arePatchesEnabled: linkType.editsEnabled ?? false
-    }
-  };
-}
-function cleanAndValidateLinkTypeId(apiName) {
+export function cleanAndValidateLinkTypeId(apiName) {
   // Insert a dash before any uppercase letter that follows a lowercase letter or digit
   const step1 = apiName.replace(/([a-z0-9])([A-Z])/g, "$1-$2");
   // Insert a dash after a sequence of uppercase letters when followed by a lowercase letter
@@ -529,78 +179,13 @@ function cleanAndValidateLinkTypeId(apiName) {
   }
   return linkTypeId;
 }
-function convertInterface(interfaceType) {
-  const {
-    __type,
-    ...other
-  } = interfaceType;
-  return {
-    ...other,
-    propertiesV2: Object.fromEntries(Object.values(interfaceType.propertiesV2).map(spt => [spt.sharedPropertyType.apiName, {
-      required: spt.required,
-      sharedPropertyType: convertSpt(spt.sharedPropertyType)
-    }])),
-    displayMetadata: {
-      displayName: interfaceType.displayMetadata.displayName,
-      description: interfaceType.displayMetadata.description
-    },
-    extendsInterfaces: interfaceType.extendsInterfaces.map(i => i.apiName),
-    // these are omitted from our internal types but we need to re-add them for the final json
-    properties: [],
-    // TODO(mwalther): Support propertiesV3
-    propertiesV3: {}
-  };
-}
 export function dumpOntologyFullMetadata() {
-  return convertToWireOntologyIr(ontologyDefinition);
+  return convertOntologyDefinition(ontologyDefinition);
 }
 export function dumpValueTypeWireType() {
   return convertOntologyToValueTypeIr(ontologyDefinition);
 }
-function convertSpt({
-  type,
-  array,
-  description,
-  apiName,
-  displayName,
-  visibility,
-  gothamMapping,
-  typeClasses,
-  valueType,
-  nullability
-}) {
-  const dataConstraint = convertNullabilityToDataConstraint({
-    type,
-    nullability
-  });
-  return {
-    apiName,
-    displayMetadata: {
-      displayName: displayName ?? apiName,
-      visibility: visibility ?? "NORMAL",
-      description
-    },
-    type: array ? {
-      type: "array",
-      array: {
-        subtype: convertType(type)
-      }
-    } : convertType(type),
-    aliases: [],
-    baseFormatter: undefined,
-    dataConstraints: dataConstraint,
-    gothamMapping: gothamMapping,
-    indexedForSearch: true,
-    typeClasses: typeClasses ?? [],
-    valueType: valueType === undefined ? undefined : {
-      apiName: valueType.apiName,
-      version: valueType.version,
-      packageNamespace: valueType.packageNamespace,
-      displayMetadata: valueType.displayMetadata
-    }
-  };
-}
-function convertObjectStatus(status) {
+export function convertObjectStatus(status) {
   if (status === undefined) {
     return {
       type: "active",
@@ -631,7 +216,7 @@ function convertObjectStatus(status) {
   }
   return status;
 }
-function convertAction(action) {
+export function convertAction(action) {
   const actionValidation = convertActionValidation(action);
   const actionParameters = convertActionParameters(action);
   const actionSections = convertActionSections(action);
@@ -694,95 +279,6 @@ function convertAction(action) {
     }
   };
 }
-function convertActionValidation(action) {
-  return {
-    actionTypeLevelValidation: {
-      rules: Object.fromEntries((action.validation ?? [{
-        condition: {
-          type: "true",
-          true: {}
-        },
-        displayMetadata: {
-          failureMessage: "",
-          typeClasses: []
-        }
-      }]).map((rule, idx) => [idx, rule]))
-    },
-    parameterValidations: Object.fromEntries((action.parameters ?? []).map(p => {
-      return [p.id, {
-        defaultValidation: {
-          display: {
-            renderHint: renderHintFromBaseType(p),
-            visibility: convertActionVisibility(p.validation.defaultVisibility),
-            ...(p.defaultValue && {
-              prefill: p.defaultValue
-            })
-          },
-          validation: {
-            allowedValues: extractAllowedValues(p.validation.allowedValues),
-            required: convertParameterRequirementConstraint(p.validation.required)
-          }
-        },
-        conditionalOverrides: p.validation.conditionalOverrides?.map(override => convertActionParameterConditionalOverride(override, p.validation)) ?? []
-      }];
-    })),
-    sectionValidations: {
-      ...Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [section.id, {
-        defaultDisplayMetadata: section.defaultVisibility === "hidden" ? {
-          visibility: {
-            type: "hidden",
-            hidden: {}
-          }
-        } : {
-          visibility: {
-            type: "visible",
-            visible: {}
-          }
-        },
-        conditionalOverrides: section.conditionalOverrides?.map(override => convertSectionConditionalOverride(override, section.defaultVisibility ?? "visible")) ?? []
-      }]))
-    }
-  };
-}
-function convertActionParameters(action) {
-  return Object.fromEntries((action.parameters ?? []).map(p => [p.id, {
-    id: p.id,
-    type: typeof p.type === "string" ? {
-      type: p.type,
-      [p.type]: {}
-    } : p.type,
-    displayMetadata: {
-      displayName: p.displayName,
-      description: p.description ?? "",
-      typeClasses: []
-    }
-  }]));
-}
-function convertActionSections(action) {
-  return Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [sectionId, {
-    id: sectionId,
-    content: section.parameters.map(p => ({
-      type: "parameterId",
-      parameterId: p
-    })),
-    displayMetadata: {
-      collapsedByDefault: section.collapsedByDefault ?? false,
-      columnCount: section.columnCount ?? 1,
-      description: section.description ?? "",
-      displayName: section.displayName ?? convertToDisplayName(sectionId),
-      showTitleBar: section.showTitleBar ?? true,
-      ...(section.style && {
-        style: section.style === "box" ? {
-          type: "box",
-          box: {}
-        } : {
-          type: "minimal",
-          minimal: {}
-        }
-      })
-    }
-  }]));
-}
 export function extractAllowedValues(allowedValues) {
   switch (allowedValues.type) {
     case "oneOf":
@@ -899,7 +395,7 @@ export function extractAllowedValues(allowedValues) {
     // TODO(dpaquin): there's probably a TS clean way to do this
   }
 }
-function renderHintFromBaseType(parameter) {
+export function renderHintFromBaseType(parameter) {
   // TODO(dpaquin): these are just guesses, we should find where they're actually defined
   const type = typeof parameter.type === "string" ? parameter.type : parameter.type.type;
   switch (type) {
@@ -982,31 +478,6 @@ function renderHintFromBaseType(parameter) {
       throw new Error(`Unknown type ${type}`);
   }
 }
-function convertParameterRequirementConstraint(required) {
-  if (typeof required === "boolean") {
-    return required ? {
-      type: "required",
-      required: {}
-    } : {
-      type: "notRequired",
-      notRequired: {}
-    };
-  }
-  const {
-    min,
-    max
-  } = required.listLength;
-  return {
-    type: "listLengthValidation",
-    listLengthValidation: {
-      minLength: min,
-      maxLength: max
-    }
-  };
-}
-export function sanitize(namespace, s) {
-  return s.includes(".") ? s : namespace + s;
-}
 export function extractNamespace(apiName) {
   return apiName.substring(0, apiName.lastIndexOf(".") + 1);
 }
@@ -1052,10 +523,4 @@ addDependency("${namespaceNoDot}", new URL(import.meta.url).pathname);
 export function addNamespaceIfNone(apiName) {
   return apiName.includes(".") ? apiName : namespace + apiName;
 }
-function convertCardinality(cardinality) {
-  if (cardinality === "OneToMany" || cardinality === undefined) {
-    return "ONE_TO_MANY";
-  }
-  return "ONE_TO_ONE";
-}
 //# sourceMappingURL=defineOntology.js.map