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

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

@@ -1,677 +0,0 @@
-/*
- * 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