@osdk/maker-experimental 0.6.0-beta.9 → 0.6.0

package/build/cjs/index.cjs

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var chunkXMO5RRJG_cjs = require('./chunk-XMO5RRJG.cjs');
+var maker = require('@osdk/maker');
 var consola = require('consola');
 var jiti = require('jiti');
 var fs = require('fs');
@@ -10,7 +11,6 @@ var path = require('path');
 var invariant5 = require('tiny-invariant');
 var yargs = require('yargs');
 var helpers = require('yargs/helpers');
-var maker = require('@osdk/maker');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -4052,10 +4052,15 @@ async function defineOntologyV2(ns, body, randomnessKey) {
   const ontDef = convertOntologyDefinition(ontologyDefinition, ridGenerator, randomnessKey);
   const shapes = await getShapes(ontDef.ontology, ridGenerator, randomnessKey);
   const backingDatasourceApiNames = Object.entries(ontologyDefinition[maker.OntologyEntityTypeEnum.OBJECT_TYPE]).filter(([_, obj]) => obj.includeEmptyBackingDatasource === true).map(([apiName]) => apiName);
+  const backingDatasourceLinkApiNames = Object.entries(ontologyDefinition[maker.OntologyEntityTypeEnum.LINK_TYPE]).filter(([_, link]) => {
+    const lt = link;
+    return "many" in lt && !("intermediaryObjectType" in lt) && lt.includeEmptyBackingDatasource === true;
+  }).map(([apiName]) => apiName);
   return {
     ontologyIr: ontDef,
     shapes,
-    backingDatasourceApiNames
+    backingDatasourceApiNames,
+    backingDatasourceLinkApiNames
   };
 }
 function propertyTypeToSchemaType(propType) {
@@ -4109,23 +4114,16 @@ function getNonEditOnlyProperties(objectTypeBlockData) {
   const editOnlyRids = getEditOnlyPropertyRids(objectTypeBlockData.datasources);
   return Object.entries(objectTypeBlockData.objectType.propertyTypes).filter(([rid]) => !editOnlyRids.has(rid)).map(([_, prop]) => prop);
 }
-async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir, randomnessKey) {
-  const apiName = objectTypeBlockData.objectType.apiName;
-  const nonEditOnlyProps = getNonEditOnlyProperties(objectTypeBlockData);
-  const dsName = `${apiName}-backing-ds`;
+async function generateBackingDatasetBlock(datasetName, blockIdentifier, dirSuffix, columns, buildDir, randomnessKey) {
   const outputs = {};
-  const datasourceReadableId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetOutput(apiName);
-  const columnReadableIds = [];
-  for (const prop of nonEditOnlyProps) {
-    const colReadableId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetColumnOutput(apiName, prop.apiName);
-    columnReadableIds.push(colReadableId);
-  }
+  const datasourceReadableId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetOutput(datasetName);
+  const columnReadableIds = columns.map((col) => chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetColumnOutput(datasetName, col.name));
   const datasourceBlockInternalId = chunkXMO5RRJG_cjs.toBlockShapeId(datasourceReadableId, randomnessKey);
   outputs[datasourceReadableId] = {
     type: "tabularDatasource",
     tabularDatasource: {
       about: {
-        fallbackTitle: dsName,
+        fallbackTitle: blockIdentifier,
         fallbackDescription: "",
         localizedTitle: {},
         localizedDescription: {}
@@ -4137,32 +4135,32 @@ async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir,
       }
     }
   };
-  for (let i = 0; i < nonEditOnlyProps.length; i++) {
-    const prop = nonEditOnlyProps[i];
+  for (let i = 0; i < columns.length; i++) {
+    const col = columns[i];
     const colReadableId = columnReadableIds[i];
     outputs[colReadableId] = {
       type: "datasourceColumn",
       datasourceColumn: {
         about: {
-          fallbackTitle: prop.apiName,
+          fallbackTitle: col.name,
           fallbackDescription: "",
           localizedTitle: {},
           localizedDescription: {}
         },
         type: {
           type: "concrete",
-          concrete: typeToConcreteDataType(prop.type)
+          concrete: typeToConcreteDataType(col.type)
         },
         datasource: datasourceBlockInternalId,
         typeclasses: []
       }
     };
   }
-  const columnInternalIds = nonEditOnlyProps.map((prop) => chunkXMO5RRJG_cjs.toBlockShapeId(`column-internal-${apiName}-${prop.apiName}`, randomnessKey));
-  const compassReadableId = `${dsName}-compass-resource`;
+  const columnInternalIds = columns.map((col) => chunkXMO5RRJG_cjs.toBlockShapeId(`column-internal-${datasetName}-${col.name}`, randomnessKey));
+  const compassReadableId = `${blockIdentifier}-compass-resource`;
   const compassBlockShapeId = chunkXMO5RRJG_cjs.toBlockShapeId(compassReadableId, randomnessKey);
-  const datasourceInternalId = chunkXMO5RRJG_cjs.toBlockShapeId(`datasource-internal-${apiName}`, randomnessKey);
-  const locationInternalId = chunkXMO5RRJG_cjs.toBlockShapeId(`location-internal-${apiName}`, randomnessKey);
+  const datasourceInternalId = chunkXMO5RRJG_cjs.toBlockShapeId(`datasource-internal-${datasetName}`, randomnessKey);
+  const locationInternalId = chunkXMO5RRJG_cjs.toBlockShapeId(`location-internal-${datasetName}`, randomnessKey);
   const addOnOverride = {
     idToBlockShapeId: {
       "dataset-internal-shape-id": datasourceBlockInternalId,
@@ -4175,14 +4173,14 @@ async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir,
       [datasourceBlockInternalId]: compassBlockShapeId
     }
   };
-  const dsBlockDataDir = path__namespace.join(buildDir, `temp_block_data_${apiName}_backing_ds`);
+  const dsBlockDataDir = path__namespace.join(buildDir, `temp_block_data_${dirSuffix}`);
   await fs__namespace.promises.mkdir(dsBlockDataDir, {
     recursive: true
   });
   const schemaJson = {
-    fieldSchemaList: nonEditOnlyProps.map((prop) => ({
-      type: propertyTypeToSchemaType(prop.type),
-      name: prop.apiName,
+    fieldSchemaList: columns.map((col) => ({
+      type: propertyTypeToSchemaType(col.type),
+      name: col.name,
       nullable: null,
       userDefinedTypeClass: null,
       customMetadata: {},
@@ -4204,7 +4202,7 @@ async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir,
   const blockDataJson = {
     type: "v1",
     v1: {
-      columns: Object.fromEntries(nonEditOnlyProps.map((prop, i) => [columnInternalIds[i], prop.apiName])),
+      columns: Object.fromEntries(columns.map((col, i) => [columnInternalIds[i], col.name])),
       hasSchema: true
     }
   };
@@ -4217,7 +4215,7 @@ async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir,
     type: "compassResource",
     compassResource: {
       about: {
-        fallbackTitle: dsName,
+        fallbackTitle: blockIdentifier,
         fallbackDescription: "",
         localizedTitle: {},
         localizedDescription: {}
@@ -4232,7 +4230,7 @@ async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir,
     }
   };
   return {
-    block_identifier: dsName,
+    block_identifier: blockIdentifier,
     block_data_directory: dsBlockDataDir,
     oci_block_data_metadata: void 0,
     maven_block_data_metadata: void 0,
@@ -4245,13 +4243,55 @@ async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir,
     block_type: "STATIC_DATASET"
   };
 }
+async function generateBackingDatasetBlockResult(objectTypeBlockData, buildDir, randomnessKey) {
+  const apiName = objectTypeBlockData.objectType.apiName;
+  const nonEditOnlyProps = getNonEditOnlyProperties(objectTypeBlockData);
+  const columns = nonEditOnlyProps.map((prop) => ({
+    name: prop.apiName,
+    type: prop.type
+  }));
+  return generateBackingDatasetBlock(apiName, `${apiName}-backing-ds`, `${apiName}_backing_ds`, columns, buildDir, randomnessKey);
+}
+async function generateBackingDatasetBlockResultForLink(linkTypeBlockData, linkApiName, objectTypes, buildDir, randomnessKey) {
+  const definition = linkTypeBlockData.linkType.definition;
+  if (definition.type !== "manyToMany") {
+    throw new Error(`Link type "${linkApiName}" is not a many-to-many link type`);
+  }
+  const m2m = definition.manyToMany;
+  const datasource = linkTypeBlockData.datasources[0]?.datasource;
+  if (!datasource || datasource.type !== "dataset") {
+    throw new Error(`Link type "${linkApiName}" does not have a dataset datasource`);
+  }
+  const ds = datasource.dataset;
+  const pkRidA = Object.keys(ds.objectTypeAPrimaryKeyMapping)[0];
+  const columnA = Object.values(ds.objectTypeAPrimaryKeyMapping)[0];
+  const pkRidB = Object.keys(ds.objectTypeBPrimaryKeyMapping)[0];
+  const columnB = Object.values(ds.objectTypeBPrimaryKeyMapping)[0];
+  const objectTypeA = objectTypes[m2m.objectTypeRidA];
+  const objectTypeB = objectTypes[m2m.objectTypeRidB];
+  if (!objectTypeA || !objectTypeB) {
+    throw new Error(`Could not find object types for link "${linkApiName}"`);
+  }
+  const propTypeA = objectTypeA.objectType.propertyTypes[pkRidA]?.type;
+  const propTypeB = objectTypeB.objectType.propertyTypes[pkRidB]?.type;
+  if (!propTypeA || !propTypeB) {
+    throw new Error(`Could not find primary key property types for link "${linkApiName}"`);
+  }
+  return generateBackingDatasetBlock(`link.${linkApiName}`, `${linkApiName}-link-backing-ds`, `${linkApiName}_link_backing_ds`, [{
+    name: columnA,
+    type: propTypeA
+  }, {
+    name: columnB,
+    type: propTypeB
+  }], buildDir, randomnessKey);
+}
 
 // src/cli/main.ts
 var apiNamespaceRegex = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.$/;
 var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 async function main(args = process.argv) {
   consola.consola.log("Generating BlockGeneratorResult for ontology...");
-  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.6.0-beta.9").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.6.0").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -4296,7 +4336,8 @@ async function main(args = process.argv) {
   const {
     ontologyIr,
     shapes,
-    backingDatasourceApiNames
+    backingDatasourceApiNames,
+    backingDatasourceLinkApiNames
   } = await loadOntology(commandLineOpts.input, apiNamespace, commandLineOpts.randomnessKey);
   const blockDataDir = path__namespace.join(commandLineOpts.buildDir, "temp_block_data");
   if (!fs__namespace.existsSync(blockDataDir)) {
@@ -4332,6 +4373,33 @@ async function main(args = process.argv) {
       }
     }
   }
+  for (const linkApiName of backingDatasourceLinkApiNames) {
+    const linkTypeBlockData = findLinkTypeByApiName(ontologyIr.ontology.linkTypes, linkApiName);
+    if (!linkTypeBlockData) continue;
+    const datasetName = `link.${linkApiName}`;
+    const inputDsId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDataset(datasetName);
+    const outputDsId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetOutput(datasetName);
+    if (shapes.inputShapes.has(inputDsId)) {
+      ontologyInputMappingEntries.push({
+        input: inputDsId,
+        output: outputDsId
+      });
+    }
+    const ds = linkTypeBlockData.datasources[0]?.datasource;
+    if (ds?.type === "dataset") {
+      const columnNames = [...Object.values(ds.dataset.objectTypeAPrimaryKeyMapping).map(String), ...Object.values(ds.dataset.objectTypeBPrimaryKeyMapping).map(String)];
+      for (const colName of columnNames) {
+        const colInputId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetColumn(datasetName, colName);
+        const colOutputId = chunkXMO5RRJG_cjs.ReadableIdGenerator.getForDatasetColumnOutput(datasetName, colName);
+        if (shapes.inputShapes.has(colInputId)) {
+          ontologyInputMappingEntries.push({
+            input: colInputId,
+            output: colOutputId
+          });
+        }
+      }
+    }
+  }
   const backingDsGeneratorResults = await Promise.all(backingDatasourceApiNames.filter((apiName) => {
     const objectTypeBlockData = findObjectTypeByApiName(ontologyIr.ontology.objectTypes, apiName);
     return objectTypeBlockData !== void 0;
@@ -4340,6 +4408,12 @@ async function main(args = process.argv) {
     consola.consola.info(`Generating backing datasource BlockGeneratorResult for ${apiName}...`);
     return await generateBackingDatasetBlockResult(objectTypeBlockData, commandLineOpts.buildDir, commandLineOpts.randomnessKey);
   }));
+  const backingDsLinkGeneratorResults = await Promise.all(backingDatasourceLinkApiNames.map((linkApiName) => {
+    const linkTypeBlockData = findLinkTypeByApiName(ontologyIr.ontology.linkTypes, linkApiName);
+    if (!linkTypeBlockData) return void 0;
+    consola.consola.info(`Generating backing datasource BlockGeneratorResult for link ${linkApiName}...`);
+    return generateBackingDatasetBlockResultForLink(linkTypeBlockData, linkApiName, ontologyIr.ontology.objectTypes, commandLineOpts.buildDir, commandLineOpts.randomnessKey);
+  }).filter((p) => p !== void 0));
   const blockGeneratorResult = {
     block_identifier: "ontology",
     block_data_directory: blockDataDir,
@@ -4353,7 +4427,7 @@ async function main(args = process.argv) {
     input_shape_metadata: Object.fromEntries(shapes.inputShapeMetadata),
     block_type: "ONTOLOGY"
   };
-  const blockGeneratorResultJson = JSON.stringify([blockGeneratorResult, ...backingDsGeneratorResults], null, 2);
+  const blockGeneratorResultJson = JSON.stringify([blockGeneratorResult, ...backingDsGeneratorResults, ...backingDsLinkGeneratorResults], null, 2);
   await fs__namespace.promises.writeFile(commandLineOpts.output, blockGeneratorResultJson);
   consola.consola.success(`BlockGeneratorResult written to ${commandLineOpts.output}`);
   consola.consola.info(`Block data directory: ${blockDataDir}`);
@@ -4372,6 +4446,10 @@ async function loadOntology(input, apiNamespace, randomnessKey) {
 function findObjectTypeByApiName(objectTypes, apiName) {
   return Object.values(objectTypes).find((objectTypeBlockData) => objectTypeBlockData.objectType.apiName === apiName);
 }
+function findLinkTypeByApiName(linkTypes, apiName) {
+  const linkTypeId = maker.cleanAndValidateLinkTypeId(apiName);
+  return Object.values(linkTypes).find((lt) => lt.linkType.id === linkTypeId);
+}
 function defineImportObject(objectDef) {
   const properties = Object.entries(objectDef.properties ?? {}).map(([apiName, type]) => ({
     apiName,