@osdk/maker 0.10.1 → 0.11.0-beta.10

package/build/cjs/index.cjs

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var consola = require('consola');
+var jiti = require('jiti');
 var fs2 = require('fs/promises');
 var path2 = require('path');
 var invariant = require('tiny-invariant');
@@ -10,6 +11,7 @@ var yargs = require('yargs');
 var helpers = require('yargs/helpers');
 var fs = require('fs');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
@@ -60,6 +62,7 @@ function defineObject(objectDef) {
   }
   !propertyApiNames.includes(objectDef.titlePropertyApiName) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Title property ${objectDef.titlePropertyApiName} is not defined on object ${objectDef.apiName}`) : invariant__default.default(false) : void 0;
   !propertyApiNames.includes(objectDef.primaryKeyPropertyApiName) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} does not exist on object ${objectDef.apiName}`) : invariant__default.default(false) : void 0;
+  !(objectDef.properties ?? []).filter((p) => p.apiName === objectDef.primaryKeyPropertyApiName).every((p) => !p.editOnly) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} on object ${objectDef.apiName} cannot be edit-only`) : invariant__default.default(false) : void 0;
   const retentionPeriod = objectDef.datasource?.retentionPeriod;
   !(retentionPeriod === void 0 || ISO_8601_DURATION.test(retentionPeriod)) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Retention period "${retentionPeriod}" on object "${objectDef.apiName}" is not a valid ISO 8601 duration string`) : invariant__default.default(false) : void 0;
   if (objectDef.status === "experimental") {
@@ -88,7 +91,7 @@ function defineObject(objectDef) {
       };
     };
     const baseValidations = Object.entries(interfaceImpl.implements.propertiesV2).map(validateProperty);
-    const extendsValidations = interfaceImpl.implements.extendsInterfaces.flatMap((interfaceApiName) => Object.entries(ontologyDefinition[OntologyEntityTypeEnum.INTERFACE_TYPE][interfaceApiName].propertiesV2).map(validateProperty));
+    const extendsValidations = interfaceImpl.implements.extendsInterfaces.flatMap((interfaceType) => Object.entries(interfaceType.propertiesV2).map(validateProperty));
     const allFailedValidations = baseValidations.concat(extendsValidations, nonExistentInterfaceProperties).filter((val) => val.type === "invalid");
     !(allFailedValidations.length === 0) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, "\n" + allFailedValidations.map(formatValidationErrors).join("\n")) : invariant__default.default(false) : void 0;
     interfaceImpl.propertyMapping = interfaceImpl.propertyMapping.map((mapping) => ({
@@ -134,10 +137,259 @@ function validateInterfaceImplProperty(spt, mappedObjectProp, object) {
     type: "valid"
   };
 }
+function convertToDisplayName(s) {
+  return s === void 0 || s == null ? "" : s.charAt(0).toUpperCase() + s.slice(1);
+}
+function convertToPluralDisplayName(s) {
+  return s === void 0 || s == null ? "" : s.endsWith("s") ? convertToDisplayName(s) : convertToDisplayName(s) + "s";
+}
+var defaultTypeClasses = [{
+  kind: "render_hint",
+  name: "SELECTABLE"
+}, {
+  kind: "render_hint",
+  name: "SORTABLE"
+}];
+function shouldNotHaveRenderHints(type) {
+  return ["struct", "mediaReference", "geotimeSeries"].includes(getPropertyTypeName(type));
+}
+function hasRenderHints(typeClasses) {
+  return (typeClasses ?? []).some((tc) => tc.kind.toLowerCase() === "render_hint");
+}
+function getPropertyTypeName(type) {
+  return typeof type === "object" ? type.type : type;
+}
+function convertValueType(valueType) {
+  return {
+    apiName: valueType.apiName,
+    version: valueType.version
+  };
+}
+function convertValueTypeDataConstraints(dataConstraints) {
+  if (dataConstraints.length === 0) {
+    return void 0;
+  }
+  const propertyTypeConstraints = dataConstraints.map((constraint) => ({
+    constraints: dataConstraintToPropertyTypeDataConstraint(constraint.constraint.constraint),
+    failureMessage: constraint.constraint.failureMessage
+  }));
+  return {
+    propertyTypeConstraints
+  };
+}
+function dataConstraintToPropertyTypeDataConstraint(dc) {
+  switch (dc.type) {
+    case "array":
+      return {
+        ...dc
+      };
+    case "boolean":
+      return {
+        ...dc
+      };
+    case "binary":
+      throw new Error("Binary type constraints are not supported");
+    case "date":
+      return {
+        ...dc
+      };
+    case "decimal":
+      return {
+        ...dc
+      };
+    case "double":
+      return {
+        ...dc
+      };
+    case "float":
+      return {
+        ...dc
+      };
+    case "integer":
+      return {
+        ...dc
+      };
+    case "long":
+      return {
+        ...dc
+      };
+    case "map":
+      throw new Error("Map type constraints are not supported");
+    case "nullable":
+      throw new Error("Nullable constraints are not supported");
+    case "short":
+      return {
+        ...dc
+      };
+    case "string":
+      return {
+        ...dc
+      };
+    case "struct":
+      return {
+        type: "struct",
+        struct: {
+          elementConstraints: Object.fromEntries(Object.entries(dc.struct.elementConstraints).map(([field, constraint]) => [field, convertDataConstraintToDataConstraints(constraint)]))
+        }
+      };
+    case "structV2":
+      throw new Error("StructV2 constraints are not supported");
+    case "timestamp":
+      return {
+        ...dc
+      };
+    default:
+      throw new Error(`Unknown DataConstraint type: ${dc.type}`);
+  }
+}
+function convertDataConstraintToDataConstraints(dc) {
+  return {
+    propertyTypeConstraints: [{
+      constraints: dataConstraintToPropertyTypeDataConstraint(dc)
+      // known limitation: structs don't carry field-level data constraint failure messages
+    }]
+  };
+}
+function convertNullabilityToDataConstraint(prop) {
+  if (typeof prop.type === "object" && prop.type.type === "marking") {
+    if (prop.nullability === void 0) {
+      return {
+        propertyTypeConstraints: [],
+        nullability: void 0,
+        nullabilityV2: {
+          noEmptyCollections: true,
+          noNulls: true
+        }
+      };
+    }
+    !prop.nullability?.noNulls ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, "Marking property type has noNulls set to false, marking properties must not be nullable") : invariant__default.default(false) : void 0;
+    return {
+      propertyTypeConstraints: [],
+      nullability: void 0,
+      nullabilityV2: prop.nullability
+    };
+  }
+  return prop.nullability === void 0 ? void 0 : {
+    propertyTypeConstraints: [],
+    nullability: void 0,
+    nullabilityV2: prop.nullability
+  };
+}
+function convertType(type) {
+  switch (true) {
+    case (typeof type === "object" && "markingType" in type):
+      return {
+        "type": "marking",
+        marking: {
+          markingType: type.markingType
+        }
+      };
+    case (typeof type === "object" && "structDefinition" in type):
+      const structFields = new Array();
+      for (const key in type.structDefinition) {
+        const fieldTypeDefinition = type.structDefinition[key];
+        let field;
+        if (typeof fieldTypeDefinition === "string") {
+          field = {
+            apiName: key,
+            displayMetadata: {
+              displayName: key,
+              description: void 0
+            },
+            typeClasses: [],
+            aliases: [],
+            fieldType: convertType(fieldTypeDefinition)
+          };
+        } else {
+          if ("fieldType" in fieldTypeDefinition) {
+            field = {
+              ...fieldTypeDefinition,
+              apiName: key,
+              fieldType: convertType(fieldTypeDefinition.fieldType),
+              typeClasses: fieldTypeDefinition.typeClasses ?? [],
+              aliases: fieldTypeDefinition.aliases ?? []
+            };
+          } else {
+            field = {
+              apiName: key,
+              displayMetadata: {
+                displayName: key,
+                description: void 0
+              },
+              typeClasses: [],
+              aliases: [],
+              fieldType: convertType(fieldTypeDefinition)
+            };
+          }
+        }
+        structFields.push(field);
+      }
+      return {
+        type: "struct",
+        struct: {
+          structFields
+        }
+      };
+    case (typeof type === "object" && "isLongText" in type):
+      return {
+        "type": "string",
+        "string": {
+          analyzerOverride: void 0,
+          enableAsciiFolding: void 0,
+          isLongText: type.isLongText,
+          supportsEfficientLeadingWildcard: type.supportsEfficientLeadingWildcard,
+          supportsExactMatching: type.supportsExactMatching
+        }
+      };
+    case type === "geopoint":
+      return {
+        type: "geohash",
+        geohash: {}
+      };
+    case type === "decimal":
+      return {
+        type,
+        [type]: {
+          precision: void 0,
+          scale: void 0
+        }
+      };
+    case type === "string":
+      return {
+        type,
+        [type]: {
+          analyzerOverride: void 0,
+          enableAsciiFolding: void 0,
+          isLongText: false,
+          supportsEfficientLeadingWildcard: false,
+          supportsExactMatching: true
+        }
+      };
+    case type === "mediaReference":
+      return {
+        type,
+        mediaReference: {}
+      };
+    case type === "geotimeSeries":
+      return {
+        type: "geotimeSeriesReference",
+        geotimeSeriesReference: {}
+      };
+    default:
+      return distributeTypeHelper(type);
+  }
+}
+function distributeTypeHelper(type) {
+  return {
+    type,
+    [type]: {}
+  };
+}
 
 // src/api/defineOntology.ts
 var ontologyDefinition;
 var importedTypes;
+var dependencies;
 var namespace;
 function updateOntology(entity) {
   if (entity.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
@@ -149,8 +401,9 @@ function updateOntology(entity) {
   }
   ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName].push(entity);
 }
-async function defineOntology(ns, body, outputDir) {
+async function defineOntology(ns, body, outputDir, dependencyFile) {
   namespace = ns;
+  dependencies = {};
   ontologyDefinition = {
     OBJECT_TYPE: {},
     ACTION_TYPE: {},
@@ -173,7 +426,12 @@ async function defineOntology(ns, body, outputDir) {
     console.error("Unexpected error while processing the body of the ontology", e);
     throw e;
   }
-  writeStaticObjects(outputDir);
+  if (outputDir) {
+    writeStaticObjects(outputDir);
+  }
+  if (dependencyFile) {
+    writeDependencyFile(dependencyFile);
+  }
   return {
     ontology: convertToWireOntologyIr(ontologyDefinition),
     valueType: convertOntologyToValueTypeIr(ontologyDefinition)
@@ -230,11 +488,11 @@ export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFi
       entityModuleNames.push(entityFileNameBase);
     });
     for (const entityModuleName of entityModuleNames) {
-      topLevelExportStatements.push(`export { ${entityModuleName} } from './codegen/${typeDirName}/${entityModuleName}.js';`);
+      topLevelExportStatements.push(`export { ${entityModuleName} } from "./codegen/${typeDirName}/${entityModuleName}.js";`);
     }
   });
   if (topLevelExportStatements.length > 0) {
-    const mainIndexContent = topLevelExportStatements.join("\n") + "\n";
+    const mainIndexContent = dependencyInjectionString() + topLevelExportStatements.join("\n") + "\n";
     const mainIndexFilePath = path2__namespace.join(outputDir, "index.ts");
     fs__namespace.writeFileSync(mainIndexFilePath, mainIndexContent, {
       flag: "w"
@@ -366,7 +624,15 @@ function convertToWireBlockData(ontology) {
       return [apiName, convertAction(action)];
     })),
     blockPermissionInformation: {
-      actionTypes: {},
+      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: {}
     }
@@ -474,39 +740,54 @@ function convertDatasourceDefinition(objectType, properties) {
           propertySecurityGroups: void 0
         }
       };
+    case "restrictedView":
+      return {
+        type: "restrictedViewV2",
+        restrictedViewV2: {
+          restrictedViewRid: objectType.apiName,
+          propertyMapping: buildPropertyMapping(properties)
+        }
+      };
     case "dataset":
     default:
-      const datasetPropertyMapping = Object.fromEntries(properties.map((prop) => {
-        prop.type;
-        if (typeof prop.type === "object" && prop.type?.type === "struct") {
-          const structMapping = {
-            type: "struct",
-            struct: {
-              column: prop.apiName,
-              mapping: Object.fromEntries(Object.entries(prop.type.structDefinition).map(([fieldName, _fieldType]) => [fieldName, {
-                apiName: fieldName,
-                mappings: {}
-              }]))
-            }
-          };
-          return [prop.apiName, structMapping];
-        } else {
-          return [prop.apiName, {
-            type: "column",
-            column: prop.apiName
-          }];
-        }
-      }));
       return {
         type: "datasetV2",
         datasetV2: {
           datasetRid: objectType.apiName,
-          propertyMapping: datasetPropertyMapping
+          propertyMapping: buildPropertyMapping(properties)
         }
       };
   }
 }
+function buildPropertyMapping(properties) {
+  return Object.fromEntries(properties.map((prop) => {
+    prop.type;
+    if (typeof prop.type === "object" && prop.type?.type === "struct") {
+      const structMapping = {
+        type: "struct",
+        struct: {
+          column: prop.apiName,
+          mapping: Object.fromEntries(Object.entries(prop.type.structDefinition).map(([fieldName, _fieldType]) => [fieldName, {
+            apiName: fieldName,
+            mappings: {}
+          }]))
+        }
+      };
+      return [prop.apiName, structMapping];
+    } else {
+      return [prop.apiName, prop.editOnly ? {
+        type: "editOnly",
+        editOnly: {}
+      } : {
+        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__default.default(false, `Property type ${apiName} of type '${getPropertyTypeName(property.type)}' should not have render hints`) : invariant__default.default(false) : void 0;
   const output = {
     apiName: property.apiName,
     sharedPropertyTypeApiName: property.sharedPropertyType?.apiName,
@@ -519,12 +800,12 @@ function convertProperty(property) {
     ruleSetBinding: void 0,
     baseFormatter: property.baseFormatter,
     type: convertType(property.type),
-    typeClasses: property.typeClasses ?? [],
+    typeClasses: property.typeClasses ?? (shouldNotHaveRenderHints(property.type) ? [] : defaultTypeClasses),
     status: convertObjectStatus(property.status),
     inlineAction: void 0,
-    dataConstraints: convertNullabilityToDataConstraint(property),
+    dataConstraints: property.valueType ? convertValueTypeDataConstraints(property.valueType.constraints) : convertNullabilityToDataConstraint(property),
     sharedPropertyTypeRid: property.sharedPropertyType?.apiName,
-    valueType: void 0
+    valueType: property.valueType ? convertValueType(property.valueType) : void 0
   };
   return output;
 }
@@ -535,7 +816,7 @@ function convertLink(linkType) {
     definition = {
       type: "oneToMany",
       oneToMany: {
-        cardinalityHint: "ONE_TO_ONE",
+        cardinalityHint: "ONE_TO_MANY",
         manyToOneLinkMetadata: linkType.toMany.metadata,
         objectTypeRidManySide: linkType.toMany.object.apiName,
         objectTypeRidOneSide: linkType.one.object.apiName,
@@ -615,7 +896,7 @@ function convertLink(linkType) {
   return {
     linkType: {
       definition,
-      id: linkType.apiName,
+      id: cleanAndValidateLinkTypeId(linkType.apiName),
       status: linkType.status ?? {
         type: "active",
         active: {}
@@ -628,6 +909,15 @@ function convertLink(linkType) {
     }
   };
 }
+function cleanAndValidateLinkTypeId(apiName) {
+  const step1 = apiName.replace(/([a-z0-9])([A-Z])/g, "$1-$2");
+  const linkTypeId = step1.replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+  const VALIDATION_PATTERN = /^([a-z][a-z0-9\-]*)$/;
+  if (!VALIDATION_PATTERN.test(linkTypeId)) {
+    throw new Error(`LinkType id '${linkTypeId}' must be lower case with dashes.`);
+  }
+  return linkTypeId;
+}
 function convertInterface(interfaceType) {
   const {
     __type,
@@ -639,6 +929,7 @@ function convertInterface(interfaceType) {
       required: spt.required,
       sharedPropertyType: convertSpt(spt.sharedPropertyType)
     }])),
+    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
     allExtendsInterfaces: [],
     allLinks: [],
@@ -685,110 +976,6 @@ function convertSpt({
     valueType
   };
 }
-function convertType(type) {
-  switch (true) {
-    case (typeof type === "object" && "markingType" in type):
-      return {
-        "type": "marking",
-        marking: {
-          markingType: type.markingType
-        }
-      };
-    case (typeof type === "object" && "structDefinition" in type):
-      const structFields = new Array();
-      for (const key in type.structDefinition) {
-        const fieldTypeDefinition = type.structDefinition[key];
-        let field;
-        if (typeof fieldTypeDefinition === "string") {
-          field = {
-            apiName: key,
-            displayMetadata: {
-              displayName: key,
-              description: void 0
-            },
-            typeClasses: [],
-            aliases: [],
-            fieldType: convertType(fieldTypeDefinition)
-          };
-        } else {
-          if ("fieldType" in fieldTypeDefinition) {
-            field = {
-              ...fieldTypeDefinition,
-              apiName: key,
-              fieldType: convertType(fieldTypeDefinition.fieldType),
-              typeClasses: fieldTypeDefinition.typeClasses ?? [],
-              aliases: fieldTypeDefinition.aliases ?? []
-            };
-          } else {
-            field = {
-              apiName: key,
-              displayMetadata: {
-                displayName: key,
-                description: void 0
-              },
-              typeClasses: [],
-              aliases: [],
-              fieldType: convertType(fieldTypeDefinition)
-            };
-          }
-        }
-        structFields.push(field);
-      }
-      return {
-        type: "struct",
-        struct: {
-          structFields
-        }
-      };
-    case (typeof type === "object" && "isLongText" in type):
-      return {
-        "type": "string",
-        "string": {
-          analyzerOverride: void 0,
-          enableAsciiFolding: void 0,
-          isLongText: type.isLongText,
-          supportsEfficientLeadingWildcard: type.supportsEfficientLeadingWildcard,
-          supportsExactMatching: type.supportsExactMatching
-        }
-      };
-    case type === "geopoint":
-      return {
-        type: "geohash",
-        geohash: {}
-      };
-    case type === "decimal":
-      return {
-        type,
-        [type]: {
-          precision: void 0,
-          scale: void 0
-        }
-      };
-    case type === "string":
-      return {
-        type,
-        [type]: {
-          analyzerOverride: void 0,
-          enableAsciiFolding: void 0,
-          isLongText: false,
-          supportsEfficientLeadingWildcard: false,
-          supportsExactMatching: true
-        }
-      };
-    case type === "mediaReference":
-      return {
-        type,
-        mediaReference: {}
-      };
-    case type === "geotimeSeries":
-      return {
-        type: "geotimeSeriesReference",
-        geotimeSeriesReference: {}
-      };
-    default:
-      return distributeTypeHelper(type);
-  }
-}
 function convertObjectStatus(status) {
   if (status === void 0) {
     return {
@@ -1154,37 +1341,6 @@ function convertParameterRequirementConstraint(required) {
     }
   };
 }
-function convertNullabilityToDataConstraint(prop) {
-  if (typeof prop.type === "object" && prop.type.type === "marking") {
-    if (prop.nullability === void 0) {
-      return {
-        propertyTypeConstraints: [],
-        nullability: void 0,
-        nullabilityV2: {
-          noEmptyCollections: true,
-          noNulls: true
-        }
-      };
-    }
-    !prop.nullability?.noNulls ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, "Marking property type has noNulls set to false, marking properties must not be nullable") : invariant__default.default(false) : void 0;
-    return {
-      propertyTypeConstraints: [],
-      nullability: void 0,
-      nullabilityV2: prop.nullability
-    };
-  }
-  return prop.nullability === void 0 ? void 0 : {
-    propertyTypeConstraints: [],
-    nullability: void 0,
-    nullabilityV2: prop.nullability
-  };
-}
-function distributeTypeHelper(type) {
-  return {
-    type,
-    [type]: {}
-  };
-}
 function sanitize(namespace2, s) {
   return s.includes(".") ? s : namespace2 + s;
 }
@@ -1216,11 +1372,23 @@ function getEntityTypeName(type) {
     [OntologyEntityTypeEnum.VALUE_TYPE]: "ValueTypeDefinitionVersion"
   }[type];
 }
+function writeDependencyFile(dependencyFile) {
+  fs__namespace.writeFileSync(dependencyFile, JSON.stringify(dependencies, null, 2));
+}
+function dependencyInjectionString() {
+  const namespaceNoDot = namespace.endsWith(".") ? namespace.slice(0, -1) : namespace;
+  return `
+import { fileURLToPath } from "url";
+import { addDependency } from '@osdk/maker';
+
+addDependency("${namespaceNoDot}", fileURLToPath(import.meta.url));
+`;
+}
 
 // src/cli/main.ts
 var apiNamespaceRegex = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.$/;
 async function main(args = process.argv) {
-  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.10.1").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.11.0-beta.10").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -1247,11 +1415,22 @@ async function main(args = process.argv) {
       default: "snapshots",
       coerce: path2__namespace.resolve
     },
+    outputDir: {
+      alias: "d",
+      describe: "Directory for generated ontology entities",
+      type: "string",
+      coerce: path2__namespace.resolve
+    },
     valueTypesOutput: {
       describe: "Value Type Output File",
       type: "string",
       default: "value-types.json",
       coerce: path2__namespace.resolve
+    },
+    dependencies: {
+      describe: "File to write dependencies to",
+      type: "string",
+      coerce: path2__namespace.resolve
     }
   }).parseAsync();
   let apiNamespace = "";
@@ -1261,23 +1440,45 @@ async function main(args = process.argv) {
     !apiNamespaceRegex.test(apiNamespace) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, "API namespace is invalid! It is expected to conform to ^[a-z0-9-]+(.[a-z0-9-]+)*.$") : invariant__default.default(false) : void 0;
   }
   consola.consola.info(`Loading ontology from ${commandLineOpts.input}`);
-  const ontology = await loadOntology(
-    commandLineOpts.input,
-    apiNamespace,
-    path2__namespace.dirname(path2__namespace.dirname(commandLineOpts.input))
-    // "src" in "src/ontology/ontology.mjs"
-  );
+  const ontology = await loadOntology(commandLineOpts.input, apiNamespace, commandLineOpts.outputDir, commandLineOpts.dependencies);
   consola.consola.info(`Saving ontology to ${commandLineOpts.output}`);
   await fs2__namespace.writeFile(commandLineOpts.output, JSON.stringify(ontology.ontology, null, 2));
   if (ontology.valueType.valueTypes.length > 0) {
     await fs2__namespace.writeFile(commandLineOpts.valueTypesOutput, JSON.stringify(ontology.valueType, null, 2));
   }
 }
-async function loadOntology(input, apiNamespace, outputDir) {
-  const q = await defineOntology(apiNamespace, async () => await import(input), outputDir);
+async function loadOntology(input, apiNamespace, outputDir, dependencyFile) {
+  const q = await defineOntology(apiNamespace, async () => {
+    const jiti$1 = jiti.createJiti(undefined, {
+      moduleCache: false,
+      debug: false,
+      importMeta: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) })
+    });
+    const module = await jiti$1.import(input);
+  }, outputDir, dependencyFile);
   return q;
 }
-function defineCreateInterfaceObjectAction(interfaceType, objectType) {
+var MAX_SEARCH_DEPTH = 5;
+function addDependency(namespace2, fileInPackage) {
+  let dir = path2__namespace.dirname(fileInPackage);
+  let packageJsonPath = null;
+  for (let i = 0; i < MAX_SEARCH_DEPTH; i++) {
+    const candidate = path2__namespace.join(dir, "package.json");
+    if (fs__namespace.existsSync(candidate)) {
+      packageJsonPath = candidate;
+      break;
+    }
+    const parentDir = path2__namespace.dirname(dir);
+    if (parentDir === dir) break;
+    dir = parentDir;
+  }
+  if (!packageJsonPath) {
+    throw new Error(`Could not find a package.json within ${MAX_SEARCH_DEPTH} parent directories of ${fileInPackage}`);
+  }
+  const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
+  dependencies[namespace2] = packageJson.version ?? "";
+}
+function defineCreateInterfaceObjectAction(interfaceType, objectType, validation) {
   return defineAction({
     apiName: `create-${kebab(interfaceType.apiName.split(".").pop() ?? interfaceType.apiName)}${objectType === void 0 ? "" : `-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`}`,
     displayName: `Create ${interfaceType.displayMetadata.displayName}`,
@@ -1331,10 +1532,13 @@ function defineCreateInterfaceObjectAction(interfaceType, objectType) {
           parameterId: id
         }]))
       }
-    }]
+    }],
+    ...validation ? {
+      validation: [createValidationRule(validation)]
+    } : {}
   });
 }
-function defineCreateObjectAction(objectType) {
+function defineCreateObjectAction(objectType, validation) {
   return defineAction({
     apiName: `create-object-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`,
     displayName: `Create ${objectType.displayName}`,
@@ -1358,10 +1562,13 @@ function defineCreateObjectAction(objectType) {
         }])) : {},
         structFieldValues: {}
       }
-    }]
+    }],
+    ...validation ? {
+      validation: [createValidationRule(validation)]
+    } : {}
   });
 }
-function defineModifyInterfaceObjectAction(interfaceType, objectType) {
+function defineModifyInterfaceObjectAction(interfaceType, objectType, validation) {
   return defineAction({
     apiName: `modify-${kebab(interfaceType.apiName.split(".").pop() ?? interfaceType.apiName)}${objectType === void 0 ? "" : `-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`}`,
     displayName: `Modify ${interfaceType.displayMetadata.displayName}`,
@@ -1413,10 +1620,13 @@ function defineModifyInterfaceObjectAction(interfaceType, objectType) {
           parameterId: id
         }]))
       }
-    }]
+    }],
+    ...validation ? {
+      validation: [createValidationRule(validation)]
+    } : {}
   });
 }
-function defineModifyObjectAction(objectType) {
+function defineModifyObjectAction(objectType, validation) {
   return defineAction({
     apiName: `modify-object-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`,
     displayName: `Modify ${objectType.displayName}`,
@@ -1440,7 +1650,7 @@ function defineModifyObjectAction(objectType) {
       displayName: prop.displayName,
       type: extractActionParameterType(prop),
       validation: {
-        required: true,
+        required: false,
         allowedValues: extractAllowedValuesFromType(prop.type)
       }
     })) ?? []],
@@ -1455,10 +1665,13 @@ function defineModifyObjectAction(objectType) {
         }])) : {},
         structFieldValues: {}
       }
-    }]
+    }],
+    ...validation ? {
+      validation: [createValidationRule(validation)]
+    } : {}
   });
 }
-function defineDeleteObjectAction(objectType) {
+function defineDeleteObjectAction(objectType, validation) {
   return defineAction({
     apiName: `delete-object-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`,
     displayName: `Delete ${objectType.displayName}`,
@@ -1484,7 +1697,10 @@ function defineDeleteObjectAction(objectType) {
       deleteObjectRule: {
         objectToDelete: "objectToDeleteParameter"
       }
-    }]
+    }],
+    ...validation ? {
+      validation: [createValidationRule(validation)]
+    } : {}
   });
 }
 function defineAction(actionDef) {
@@ -1634,6 +1850,9 @@ function extractAllowedValuesFromType(type) {
         type: "text"
       };
     case "geopoint":
+      return {
+        type: "geohash"
+      };
     case "geoshape":
       return {
         type: "geoshape"
@@ -1681,7 +1900,7 @@ function extractActionParameterType(pt) {
     case "short":
       return maybeAddList("integer", pt);
     case "geopoint":
-      return maybeAddList("geoshape", pt);
+      return maybeAddList("geohash", pt);
     case "float":
       return maybeAddList("double", pt);
     case "geotimeSeries":
@@ -1702,57 +1921,102 @@ function kebab(s) {
 function sanitize2(s) {
   return s.includes(".") ? s : namespace + s;
 }
+function createValidationRule(actionValidation) {
+  if (!("type" in actionValidation)) {
+    return actionValidation;
+  }
+  switch (actionValidation.type) {
+    case "group":
+      return {
+        condition: {
+          type: "comparison",
+          comparison: {
+            operator: "EQUALS",
+            left: {
+              type: "userProperty",
+              userProperty: {
+                userId: {
+                  type: "currentUser",
+                  currentUser: {}
+                },
+                propertyValue: {
+                  type: "groupIds",
+                  groupIds: {}
+                }
+              }
+            },
+            right: {
+              type: "staticValue",
+              staticValue: {
+                type: "stringList",
+                stringList: {
+                  strings: [actionValidation.name]
+                }
+              }
+            }
+          }
+        },
+        displayMetadata: {
+          failureMessage: "Insufficient permissions. Missing organization membership required to submit action",
+          typeClasses: []
+        }
+      };
+    default:
+      throw new Error(`Unknown action validation type: ${actionValidation.type}`);
+  }
+}
+
+// src/api/importOntologyEntity.ts
+function importOntologyEntity(e) {
+  if (e.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
+    importedTypes[e.__type][e.apiName] = e;
+    return;
+  }
+  if (importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] === void 0) {
+    importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] = [];
+  }
+  importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName].push(e);
+}
+
+// src/api/defineImportSpt.ts
 function importSharedPropertyType(opts) {
   const {
     apiName,
     packageName,
-    typeHint
+    typeHint,
+    array
   } = opts;
+  const fullApiName = packageName === void 0 ? apiName : `${packageName}.${apiName}`;
   if (packageName !== void 0) {
     !!packageName.endsWith(".") ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, "Package name format invalid ends with period") : invariant__default.default(false) : void 0;
     !(packageName.match("[A-Z]") == null) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, "Package name includes upper case characters") : invariant__default.default(false) : void 0;
-    return {
-      apiName: packageName + "." + apiName,
-      type: typeHint,
-      nonNameSpacedApiName: apiName,
-      __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
-    };
   }
-  return {
-    apiName,
+  const spt = {
+    apiName: fullApiName,
     type: typeHint,
     nonNameSpacedApiName: apiName,
+    array: array ?? false,
     __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
   };
+  importOntologyEntity(spt);
+  return spt;
 }
-var defaultTypeClasses = [{
-  kind: "render_hint",
-  name: "SELECTABLE"
-}, {
-  kind: "render_hint",
-  name: "SORTABLE"
-}];
 function defineSharedPropertyType(sptDef) {
   const apiName = namespace + sptDef.apiName;
   !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Shared property type ${apiName} already exists`) : invariant__default.default(false) : void 0;
-  const shouldNotHaveRenderHints = ["struct", "mediaReference", "geotimeSeries"].includes(getPropertyTypeName(sptDef.type));
-  const hasRenderHints = (sptDef.typeClasses ?? []).some((tc) => tc.kind.toLowerCase() === "render_hint");
-  !(!shouldNotHaveRenderHints || !hasRenderHints) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Shared property type ${apiName} of type '${getPropertyTypeName(sptDef.type)}' should not have render hints`) : invariant__default.default(false) : void 0;
+  !(!shouldNotHaveRenderHints(sptDef.type) || !hasRenderHints(sptDef.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Shared property type ${apiName} of type '${getPropertyTypeName(sptDef.type)}' should not have render hints`) : invariant__default.default(false) : void 0;
   const fullSpt = {
     ...sptDef,
     apiName,
     nonNameSpacedApiName: sptDef.apiName,
     displayName: sptDef.displayName ?? sptDef.apiName,
     // This way the non-namespaced api name is the display name (maybe not ideal)
-    typeClasses: sptDef.typeClasses ?? (shouldNotHaveRenderHints ? [] : defaultTypeClasses),
+    typeClasses: sptDef.typeClasses ?? (shouldNotHaveRenderHints(sptDef.type) ? [] : defaultTypeClasses),
     __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
   };
   updateOntology(fullSpt);
   return fullSpt;
 }
-function getPropertyTypeName(type) {
-  return typeof type === "object" ? type.type : type;
-}
 
 // src/api/defineInterface.ts
 function defineInterface(interfaceDef) {
@@ -1770,18 +2034,7 @@ function defineInterface(interfaceDef) {
       sharedPropertyType: unifyBasePropertyDefinition(namespace, apiName2, type)
     }];
   }));
-  let extendsInterfaces = [];
-  if (interfaceDef.extends) {
-    if (typeof interfaceDef.extends === "string") {
-      extendsInterfaces = [interfaceDef.extends];
-    } else if (Array.isArray(interfaceDef.extends) && interfaceDef.extends.every((item) => typeof item === "string")) {
-      extendsInterfaces = interfaceDef.extends;
-    } else if (interfaceDef.extends.apiName !== void 0) {
-      extendsInterfaces = [interfaceDef.extends.apiName];
-    } else {
-      extendsInterfaces = interfaceDef.extends.map((item) => item.apiName);
-    }
-  }
+  const extendsInterfaces = interfaceDef.extends ? Array.isArray(interfaceDef.extends) ? interfaceDef.extends : [interfaceDef.extends] : [];
   const status = mapSimplifiedStatusToInterfaceTypeStatus(interfaceDef.status ?? {
     type: "active"
   });
@@ -1885,20 +2138,56 @@ function getLinkMeta(meta) {
     description: description ?? displayName ?? apiNameWithoutNamespace
   };
 }
+var typeIdPattern = /([a-z][a-z0-9\\-]*)/;
 function defineLink(linkDefinition) {
   if ("one" in linkDefinition) {
     const foreignKey = linkDefinition.toMany.object.properties?.find((prop) => prop.apiName === linkDefinition.manyForeignKeyProperty);
     !(foreignKey !== void 0) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Foreign key ${linkDefinition.manyForeignKeyProperty} on link ${linkDefinition.apiName} does not exist on object ${linkDefinition.toMany.object.apiName}}`) : invariant__default.default(false) : void 0;
+    !typeIdPattern.test(linkDefinition.apiName) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Top level link api names are expected to match the regex pattern ([a-z][a-z0-9\\-]*) ${linkDefinition.apiName} does not match`) : invariant__default.default(false) : void 0;
     const typesMatch = foreignKey.type === linkDefinition.one.object.properties?.find((prop) => prop.apiName === linkDefinition.one.object.primaryKeyPropertyApiName)?.type;
     !typesMatch ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Link ${linkDefinition.apiName} has type mismatch between the one side's primary key and the foreign key on the many side`) : invariant__default.default(false) : void 0;
   }
-  const linkType = {
+  const fullLinkDefinition = "one" in linkDefinition ? {
     ...linkDefinition,
+    one: convertUserOneToManyLinkDefinition(linkDefinition.one),
+    toMany: convertUserOneToManyLinkDefinition(linkDefinition.toMany)
+  } : {
+    ...linkDefinition,
+    many: convertUserManyToManyLinkDefinition(linkDefinition.many),
+    toMany: convertUserManyToManyLinkDefinition(linkDefinition.toMany)
+  };
+  const linkType = {
+    cardinality: "one" in linkDefinition ? "OneToMany" : void 0,
+    ...fullLinkDefinition,
     __type: OntologyEntityTypeEnum.LINK_TYPE
   };
   updateOntology(linkType);
   return linkType;
 }
+function convertUserOneToManyLinkDefinition(oneToMany) {
+  return {
+    ...oneToMany,
+    metadata: convertLinkTypeMetadata(oneToMany.metadata)
+  };
+}
+function convertUserManyToManyLinkDefinition(manyToMany) {
+  return {
+    ...manyToMany,
+    metadata: convertLinkTypeMetadata(manyToMany.metadata)
+  };
+}
+function convertLinkTypeMetadata(metadata) {
+  return {
+    apiName: metadata.apiName,
+    displayMetadata: {
+      displayName: metadata.displayName ?? convertToDisplayName(metadata.apiName),
+      pluralDisplayName: metadata.pluralDisplayName ?? convertToPluralDisplayName(metadata.apiName),
+      visibility: metadata.visibility ?? "NORMAL",
+      groupDisplayName: metadata.groupDisplayName ?? ""
+    },
+    typeClasses: []
+  };
+}
 function convertValueTypeTypeToBaseType(valueType) {
   switch (true) {
     case (typeof valueType === "object" && valueType.type === "array"):
@@ -1986,18 +2275,6 @@ function defineValueType(valueTypeDef) {
   return vt;
 }
 
-// src/api/importOntologyEntity.ts
-function importOntologyEntity(e) {
-  if (e.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
-    importedTypes[e.__type][e.apiName] = e;
-    return;
-  }
-  if (importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] === void 0) {
-    importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] = [];
-  }
-  importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName].push(e);
-}
-
 // src/api/wrapWithProxy.ts
 function wrapWithProxy(entity) {
   return new Proxy(entity, {
@@ -2009,6 +2286,7 @@ function wrapWithProxy(entity) {
 }
 
 exports.OntologyEntityTypeEnum = OntologyEntityTypeEnum;
+exports.addDependency = addDependency;
 exports.default = main;
 exports.defineAction = defineAction;
 exports.defineCreateInterfaceObjectAction = defineCreateInterfaceObjectAction;