@osdk/maker-experimental 0.6.0-beta.2 → 0.6.0-beta.3

package/build/esm/conversion/toMarketplace/shapeExtractors/ObjectTypeShapeExtractor.test.js

@@ -0,0 +1,677 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from "vitest";
+import { ObjectTypeShapeExtractor } from "./ObjectTypeShapeExtractor.js";
+
+// Mock BiMap implementation for testing
+class MockBiMap {
+  constructor(entries) {
+    this.forward = new Map(entries);
+    this.backward = new Map(entries.map(([k, v]) => [v, k]));
+  }
+  asMap() {
+    return this.forward;
+  }
+  get(key) {
+    return this.forward.get(key);
+  }
+  put(key, value) {
+    this.forward.set(key, value);
+    this.backward.set(value, key);
+  }
+  inverse() {
+    return new MockBiMap(Array.from(this.backward.entries()));
+  }
+  entries() {
+    return this.forward.entries();
+  }
+}
+
+// Helper to create a mock OntologyRidGenerator with overrides
+function createMockRidGenerator(overrides = {}) {
+  return {
+    getActionTypeRids: () => new MockBiMap([]),
+    getParameterRidAndIds: () => new Map(),
+    getInterfaceRids: () => new MockBiMap([]),
+    getSharedPropertyTypeRids: () => new MockBiMap([]),
+    getInterfaceLinkTypeRids: () => new MockBiMap([]),
+    getInterfacePropertyTypeRids: () => new MockBiMap([]),
+    getPropertyTypeRids: () => new MockBiMap([]),
+    getDatasourceLocators: () => new MockBiMap([]),
+    getFilesDatasourceLocators: () => new MockBiMap([]),
+    getGeotimeSeriesIntegrationRids: () => new MockBiMap([]),
+    getTimeSeriesSyncs: () => new MockBiMap([]),
+    getColumnShapes: () => new MockBiMap([]),
+    getObjectTypeRids: () => new MockBiMap([]),
+    getLinkTypeRids: () => new MockBiMap([]),
+    getGroupIds: () => new MockBiMap([]),
+    getConsumedValueTypeReferences: () => new MockBiMap([]),
+    getProducedValueTypeReferences: () => new Map(),
+    valueTypeMappingForReference: () => ({
+      input: "",
+      output: ""
+    }),
+    hashString: input => input,
+    generateRid: key => key,
+    generateRidForInterface: apiName => `interface.${apiName}`,
+    generateRidForInterfaceLinkType: (apiName, interfaceTypeApiName) => `interface-link.${interfaceTypeApiName}.${apiName}`,
+    generateRidForObjectType: apiName => `object.${apiName}`,
+    generateRidForValueType: (apiName, version) => ({
+      rid: `vt.${apiName}.${version}`,
+      versionId: version
+    }),
+    generateRidForTimeSeriesSync: name => `ts.${name}`,
+    generateRidForLinkType: linkTypeId => `link.${linkTypeId}`,
+    generateRidForGeotimeSeriesIntegration: name => `geotime.${name}`,
+    generateRidForActionType: apiName => `action.${apiName}`,
+    generateRidForParameter: (actionTypeApiName, parameterId) => `param.${actionTypeApiName}.${parameterId}`,
+    generateSptRid: apiName => `spt.${apiName}`,
+    generatePropertyRid: (apiName, objectTypeApiName) => `prop.${objectTypeApiName}.${apiName}`,
+    generateInterfacePropertyTypeRid: (apiName, interfaceTypeApiName) => `interface-prop.${interfaceTypeApiName}.${apiName}`,
+    generateStructFieldRid: (propertyApiName, apiName) => `struct-field.${propertyApiName}.${apiName}`,
+    generateLocator: dataSetName => ({
+      rid: `dataset.${dataSetName}`,
+      branchId: "main"
+    }),
+    generateStreamLocator: streamName => ({
+      streamLocatorRid: `stream.${streamName}`,
+      branchId: "main"
+    }),
+    generateRestrictedViewLocator: restrictedViewName => ({
+      rid: `restricted-view.${restrictedViewName}`
+    }),
+    generateMediaSetViewLocator: mediaSetViewName => ({
+      mediaSetRid: `media-set.${mediaSetViewName}`,
+      mediaSetViewRid: `media-set-view.${mediaSetViewName}`,
+      mediaSetBranchRid: `media-set-branch.${mediaSetViewName}`
+    }),
+    toBlockInternalId: readableId => {
+      return readableId;
+    },
+    getObjectTypeIds: () => new MockBiMap([]),
+    generateObjectTypeId: objectTypeApiName => objectTypeApiName.replace(/\./g, "-").toLowerCase(),
+    generateDatasourceRid: datasourceName => `ri.ontology.main.datasource.${datasourceName}`,
+    generateValidationRuleRid: (actionTypeApiName, index) => `validation-rule.${actionTypeApiName}.${index}`,
+    generateSectionRid: sectionId => `ri.ontology-metadata.temp.section.${sectionId}`,
+    generatePropertySecurityGroupRid: groupName => `ri.ontology-metadata.temp.property-security-group.${groupName}`,
+    ...overrides
+  };
+}
+describe("ObjectTypeShapeExtractor", () => {
+  describe("constructor", () => {
+    it("should create extractor without randomness key", () => {
+      const extractor = new ObjectTypeShapeExtractor();
+      expect(extractor).toBeDefined();
+    });
+    it("should create extractor with randomness key", () => {
+      const extractor = new ObjectTypeShapeExtractor("test-key");
+      expect(extractor).toBeDefined();
+    });
+  });
+  describe("extract", () => {
+    it("should extract basic object type with properties", () => {
+      const ridGenerator = createMockRidGenerator({
+        getPropertyTypeRids: () => new MockBiMap([["employee.id", "ri.ontology.main.property-type.employee.id"], ["employee.name", "ri.ontology.main.property-type.employee.name"]])
+      });
+      const extractor = new ObjectTypeShapeExtractor();
+      const result = extractor.extract("employee", {
+        objectType: {
+          apiName: "Employee",
+          rid: "ri.ontology.main.object-type.employee",
+          id: "employee-id",
+          displayMetadata: {
+            displayName: "Employee",
+            description: "An employee in the organization",
+            pluralDisplayName: "Employees",
+            visibility: "NORMAL",
+            icon: {
+              type: "blueprint",
+              blueprint: {
+                locator: "person",
+                color: "#2D72D2"
+              }
+            }
+          },
+          primaryKeys: ["ri.ontology.main.property-type.employee.id"],
+          propertyTypes: {
+            "ri.ontology.main.property-type.employee.id": {
+              rid: "ri.ontology.main.property-type.employee.id",
+              apiName: "id",
+              displayMetadata: {
+                displayName: "ID",
+                description: "Employee ID",
+                visibility: "NORMAL"
+              },
+              type: {
+                type: "string",
+                string: {
+                  isLongText: false,
+                  supportsExactMatching: true
+                }
+              },
+              id: "employee-id-pt-id",
+              indexedForSearch: true,
+              status: {
+                type: "active",
+                active: {}
+              },
+              typeClasses: []
+            },
+            "ri.ontology.main.property-type.employee.name": {
+              rid: "ri.ontology.main.property-type.employee.name",
+              apiName: "name",
+              displayMetadata: {
+                displayName: "Name",
+                description: "Employee name",
+                visibility: "NORMAL"
+              },
+              type: {
+                type: "string",
+                string: {
+                  isLongText: false,
+                  supportsExactMatching: true
+                }
+              },
+              id: "employee-name-pt-id",
+              indexedForSearch: true,
+              status: {
+                type: "active",
+                active: {}
+              },
+              typeClasses: []
+            }
+          },
+          titlePropertyTypeRid: "ri.ontology.main.property-type.employee.name",
+          status: {
+            type: "active",
+            active: {}
+          },
+          redacted: false,
+          implementsInterfaces: [],
+          implementsInterfaces2: [],
+          allImplementsInterfaces: {},
+          traits: {
+            workflowObjectTypeTraits: {}
+          },
+          typeGroups: []
+        },
+        datasources: [],
+        entityMetadata: {
+          aliases: [],
+          arePatchesEnabled: true,
+          diffEdits: false,
+          entityConfig: {
+            objectDbTypeConfigs: {}
+          },
+          targetStorageBackend: {
+            type: "objectStorageV2",
+            objectStorageV2: {}
+          }
+        },
+        writebackDatasets: []
+      }, ridGenerator);
+
+      // Should have output shapes for object type
+      expect(result.outputShapes.has("employee")).toBe(true);
+
+      // Output shapes will include object type + any properties that have readable IDs
+      expect(result.outputShapes.size).toBeGreaterThanOrEqual(1);
+      const objectTypeShape = result.outputShapes.get("employee");
+      expect(objectTypeShape).toBeDefined();
+      expect(objectTypeShape?.type).toBe("objectType");
+      if (objectTypeShape?.type === "objectType") {
+        expect(objectTypeShape.objectType.about.fallbackTitle).toBe("Employee");
+        expect(objectTypeShape.objectType.about.fallbackDescription).toBe("An employee in the organization");
+        expect(objectTypeShape.objectType.editsSupport).toBe("EDITS_ENABLED");
+        expect(objectTypeShape.objectType.objectsBackendVersion).toBe("V2");
+      }
+    });
+    it("should handle object type with dataset datasource", () => {
+      const datasetLocator = {
+        type: "dataset",
+        dataset: {
+          rid: "ri.foundry.main.dataset.person",
+          branch: "main"
+        }
+      };
+      const ridGenerator = createMockRidGenerator({
+        getPropertyTypeRids: () => new MockBiMap([["person.id", "ri.ontology.main.property-type.person.id"]]),
+        getDatasourceLocators: () => new MockBiMap([["person-dataset", datasetLocator]]),
+        getColumnShapes: () => new MockBiMap([["person-dataset.person_id", {
+          datasource: datasetLocator,
+          name: "person_id"
+        }]])
+      });
+      const extractor = new ObjectTypeShapeExtractor();
+      const result = extractor.extract("person", {
+        objectType: {
+          apiName: "Person",
+          rid: "ri.ontology.main.object-type.person",
+          id: "person-id",
+          displayMetadata: {
+            displayName: "Person",
+            pluralDisplayName: "People",
+            visibility: "NORMAL",
+            icon: {
+              type: "blueprint",
+              blueprint: {
+                locator: "person",
+                color: "#2D72D2"
+              }
+            }
+          },
+          primaryKeys: ["ri.ontology.main.property-type.person.id"],
+          propertyTypes: {
+            "ri.ontology.main.property-type.person.id": {
+              rid: "ri.ontology.main.property-type.person.id",
+              apiName: "id",
+              displayMetadata: {
+                displayName: "ID",
+                visibility: "NORMAL"
+              },
+              type: {
+                type: "string",
+                string: {
+                  isLongText: false,
+                  supportsExactMatching: true
+                }
+              },
+              id: "person-id-pt-id",
+              indexedForSearch: true,
+              status: {
+                type: "active",
+                active: {}
+              },
+              typeClasses: []
+            }
+          },
+          titlePropertyTypeRid: "ri.ontology.main.property-type.person.id",
+          status: {
+            type: "active",
+            active: {}
+          },
+          redacted: false,
+          implementsInterfaces: [],
+          implementsInterfaces2: [],
+          allImplementsInterfaces: {},
+          traits: {
+            workflowObjectTypeTraits: {}
+          },
+          typeGroups: []
+        },
+        datasources: [{
+          rid: "ri.foundry.main.datasource.person-dataset",
+          datasource: {
+            type: "datasetV2",
+            datasetV2: {
+              datasetRid: "ri.foundry.main.dataset.person",
+              branchId: "main",
+              propertyMapping: {
+                "ri.ontology.main.property-type.person.id": {
+                  type: "column",
+                  column: "person_id"
+                }
+              }
+            }
+          }
+        }],
+        entityMetadata: {
+          aliases: [],
+          arePatchesEnabled: false,
+          diffEdits: false,
+          entityConfig: {
+            objectDbTypeConfigs: {}
+          },
+          targetStorageBackend: {
+            type: "objectStorageV2",
+            objectStorageV2: {}
+          }
+        },
+        writebackDatasets: []
+      }, ridGenerator);
+
+      // Should have input shapes for dataset
+      expect(result.inputShapes.size).toBeGreaterThan(0);
+      expect(result.inputShapes.has("person-dataset")).toBe(true);
+      const datasetShape = result.inputShapes.get("person-dataset");
+      expect(datasetShape).toBeDefined();
+      expect(datasetShape?.type).toBe("tabularDatasource");
+      if (datasetShape?.type === "tabularDatasource") {
+        expect(datasetShape.tabularDatasource.supportedTypes).toEqual(["DATASET", "RESTRICTED_VIEW"]);
+        expect(datasetShape.tabularDatasource.about.fallbackTitle).toBe("person-dataset");
+      }
+    });
+    it("should handle object type with stream datasource", () => {
+      const streamLocator = {
+        type: "stream",
+        stream: {
+          rid: "ri.foundry.main.stream.event",
+          branch: "main"
+        }
+      };
+      const ridGenerator = createMockRidGenerator({
+        getPropertyTypeRids: () => new MockBiMap([["event.id", "ri.ontology.main.property-type.event.id"]]),
+        getDatasourceLocators: () => new MockBiMap([["event-stream", streamLocator]]),
+        getColumnShapes: () => new MockBiMap([["event-stream.event_id", {
+          datasource: streamLocator,
+          name: "event_id"
+        }]])
+      });
+      const extractor = new ObjectTypeShapeExtractor();
+      const result = extractor.extract("event", {
+        objectType: {
+          apiName: "Event",
+          rid: "ri.ontology.main.object-type.event",
+          id: "event-id",
+          displayMetadata: {
+            displayName: "Event",
+            pluralDisplayName: "Events",
+            visibility: "NORMAL",
+            icon: {
+              type: "blueprint",
+              blueprint: {
+                locator: "flash",
+                color: "#2D72D2"
+              }
+            }
+          },
+          primaryKeys: ["ri.ontology.main.property-type.event.id"],
+          propertyTypes: {
+            "ri.ontology.main.property-type.event.id": {
+              rid: "ri.ontology.main.property-type.event.id",
+              apiName: "id",
+              displayMetadata: {
+                displayName: "ID",
+                visibility: "NORMAL"
+              },
+              type: {
+                type: "string",
+                string: {
+                  isLongText: false,
+                  supportsExactMatching: true
+                }
+              },
+              id: "event-id-pt-id",
+              indexedForSearch: true,
+              status: {
+                type: "active",
+                active: {}
+              },
+              typeClasses: []
+            }
+          },
+          titlePropertyTypeRid: "ri.ontology.main.property-type.event.id",
+          status: {
+            type: "active",
+            active: {}
+          },
+          redacted: false,
+          implementsInterfaces: [],
+          implementsInterfaces2: [],
+          allImplementsInterfaces: {},
+          traits: {
+            workflowObjectTypeTraits: {}
+          },
+          typeGroups: []
+        },
+        datasources: [{
+          rid: "ri.foundry.main.datasource.event-stream",
+          datasource: {
+            type: "streamV2",
+            streamV2: {
+              streamLocator: {
+                streamLocatorRid: "ri.foundry.main.stream.event",
+                branchId: "main"
+              },
+              propertyMapping: {
+                "ri.ontology.main.property-type.event.id": "event_id"
+              },
+              retentionPolicy: {
+                type: "none",
+                none: {}
+              }
+            }
+          }
+        }],
+        entityMetadata: {
+          aliases: [],
+          arePatchesEnabled: false,
+          diffEdits: false,
+          entityConfig: {
+            objectDbTypeConfigs: {}
+          },
+          targetStorageBackend: {
+            type: "objectStorageV2",
+            objectStorageV2: {}
+          }
+        },
+        writebackDatasets: []
+      }, ridGenerator);
+
+      // Should have input shapes for stream
+      expect(result.inputShapes.has("event-stream")).toBe(true);
+      const streamShape = result.inputShapes.get("event-stream");
+      expect(streamShape).toBeDefined();
+      expect(streamShape?.type).toBe("tabularDatasource");
+      if (streamShape?.type === "tabularDatasource") {
+        expect(streamShape.tabularDatasource.supportedTypes).toEqual(["STREAM"]);
+      }
+    });
+    it("should apply randomness key to block shape IDs", () => {
+      const ridGenerator = createMockRidGenerator({
+        getPropertyTypeRids: () => new MockBiMap([["task.id", "ri.ontology.main.property-type.task.id"]])
+      });
+      const extractor = new ObjectTypeShapeExtractor("random123");
+      const result = extractor.extract("task", {
+        objectType: {
+          apiName: "Task",
+          rid: "ri.ontology.main.object-type.task",
+          id: "task-id",
+          displayMetadata: {
+            displayName: "Task",
+            pluralDisplayName: "Tasks",
+            visibility: "NORMAL",
+            icon: {
+              type: "blueprint",
+              blueprint: {
+                locator: "document",
+                color: "#2D72D2"
+              }
+            }
+          },
+          primaryKeys: ["ri.ontology.main.property-type.task.id"],
+          propertyTypes: {
+            "ri.ontology.main.property-type.task.id": {
+              rid: "ri.ontology.main.property-type.task.id",
+              apiName: "id",
+              displayMetadata: {
+                displayName: "ID",
+                visibility: "NORMAL"
+              },
+              type: {
+                type: "string",
+                string: {
+                  isLongText: false,
+                  supportsExactMatching: true
+                }
+              },
+              id: "task-id-pt-id",
+              indexedForSearch: true,
+              status: {
+                type: "active",
+                active: {}
+              },
+              typeClasses: []
+            }
+          },
+          titlePropertyTypeRid: "ri.ontology.main.property-type.task.id",
+          status: {
+            type: "active",
+            active: {}
+          },
+          redacted: false,
+          implementsInterfaces: [],
+          implementsInterfaces2: [],
+          allImplementsInterfaces: {},
+          traits: {
+            workflowObjectTypeTraits: {}
+          },
+          typeGroups: []
+        },
+        datasources: [],
+        entityMetadata: {
+          aliases: [],
+          arePatchesEnabled: false,
+          diffEdits: false,
+          entityConfig: {
+            objectDbTypeConfigs: {}
+          },
+          targetStorageBackend: {
+            type: "objectStorageV2",
+            objectStorageV2: {}
+          }
+        },
+        writebackDatasets: []
+      }, ridGenerator);
+      const taskShape = result.outputShapes.get("task");
+      expect(taskShape).toBeDefined();
+      if (taskShape?.type === "objectType") {
+        // Property type references should include randomness key if there are properties
+        const propertyShape = result.outputShapes.get("task.id");
+        if (propertyShape && propertyShape.type === "property") {
+          // Check that the property reference in object type includes randomness key
+          const propertyRefs = taskShape.objectType.propertyTypes;
+          if (propertyRefs.length > 0) {
+            expect(propertyRefs[0]).toContain("task.id");
+          }
+        }
+      }
+    });
+    it("should handle empty datasources", () => {
+      const ridGenerator = createMockRidGenerator();
+      const extractor = new ObjectTypeShapeExtractor();
+      const result = extractor.extract("simple", {
+        objectType: {
+          apiName: "Simple",
+          rid: "ri.ontology.main.object-type.simple",
+          id: "simple-id",
+          displayMetadata: {
+            displayName: "Simple",
+            pluralDisplayName: "Simples",
+            visibility: "NORMAL",
+            icon: {
+              type: "blueprint",
+              blueprint: {
+                locator: "cube",
+                color: "#2D72D2"
+              }
+            }
+          },
+          primaryKeys: ["ri.ontology.main.property-type.simple.id"],
+          propertyTypes: {},
+          titlePropertyTypeRid: "ri.ontology.main.property-type.simple.id",
+          status: {
+            type: "active",
+            active: {}
+          },
+          redacted: false,
+          implementsInterfaces: [],
+          implementsInterfaces2: [],
+          allImplementsInterfaces: {},
+          traits: {
+            workflowObjectTypeTraits: {}
+          },
+          typeGroups: []
+        },
+        datasources: [],
+        entityMetadata: {
+          aliases: [],
+          arePatchesEnabled: false,
+          diffEdits: false,
+          entityConfig: {
+            objectDbTypeConfigs: {}
+          },
+          targetStorageBackend: {
+            type: "objectStorageV2",
+            objectStorageV2: {}
+          }
+        },
+        writebackDatasets: []
+      }, ridGenerator);
+      expect(result.outputShapes.size).toBe(1); // Just the object type
+      expect(result.inputShapes.size).toBe(0); // No datasources
+    });
+    it("should handle edits disabled correctly", () => {
+      const ridGenerator = createMockRidGenerator();
+      const extractor = new ObjectTypeShapeExtractor();
+      const result = extractor.extract("readonly", {
+        objectType: {
+          apiName: "ReadOnly",
+          rid: "ri.ontology.main.object-type.readonly",
+          id: "readonly-id",
+          displayMetadata: {
+            displayName: "Read Only",
+            pluralDisplayName: "Read Only",
+            visibility: "NORMAL",
+            icon: {
+              type: "blueprint",
+              blueprint: {
+                locator: "lock",
+                color: "#2D72D2"
+              }
+            }
+          },
+          primaryKeys: ["ri.ontology.main.property-type.readonly.id"],
+          propertyTypes: {},
+          titlePropertyTypeRid: "ri.ontology.main.property-type.readonly.id",
+          status: {
+            type: "active",
+            active: {}
+          },
+          redacted: false,
+          implementsInterfaces: [],
+          implementsInterfaces2: [],
+          allImplementsInterfaces: {},
+          traits: {
+            workflowObjectTypeTraits: {}
+          },
+          typeGroups: []
+        },
+        datasources: [],
+        entityMetadata: {
+          aliases: [],
+          arePatchesEnabled: false,
+          diffEdits: false,
+          entityConfig: {
+            objectDbTypeConfigs: {}
+          },
+          targetStorageBackend: {
+            type: "objectStorageV2",
+            objectStorageV2: {}
+          }
+        },
+        writebackDatasets: []
+      }, ridGenerator);
+      const objectTypeShape = result.outputShapes.get("readonly");
+      expect(objectTypeShape).toBeDefined();
+      if (objectTypeShape?.type === "objectType") {
+        expect(objectTypeShape.objectType.editsSupport).toBe("EDITS_DISABLED");
+      }
+    });
+  });
+});
+//# sourceMappingURL=ObjectTypeShapeExtractor.test.js.map