@xlr-lib/xlr-sdk 0.1.1--canary.9.190

package/src/__tests__/sdk.test.ts

@@ -0,0 +1,303 @@
+import { test, expect, describe } from "vitest";
+import type { NamedType, OrType, ObjectType } from "@xlr-lib/xlr";
+import { parseTree } from "jsonc-parser";
+import { Types, ReferenceAssetsWebPluginManifest } from "@xlr-lib/static-xlrs";
+import type { Filters } from "../registry";
+import { XLRSDK } from "../sdk";
+import { XLRValidator } from "../validator";
+import { ValidationMessage } from "../types";
+
+const EXCLUDE: Filters = { typeFilter: "Transformed" };
+
+describe("Loading XLRs", () => {
+  test("Loading from Disk", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    expect(sdk.hasType("Asset")).toStrictEqual(true);
+    expect(sdk.hasType("AssetWrapper")).toStrictEqual(true);
+    expect(sdk.hasType("Binding")).toStrictEqual(true);
+    expect(sdk.hasType("BindingRef")).toStrictEqual(true);
+    expect(sdk.hasType("ExpressionRef")).toStrictEqual(true);
+    expect(sdk.hasType("ActionAsset")).toStrictEqual(true);
+    expect(sdk.hasType("InputAsset")).toStrictEqual(true);
+    expect(sdk.hasType("TransformedAction")).toStrictEqual(false);
+    expect(sdk.hasType("TransformedInput")).toStrictEqual(false);
+  });
+
+  test("Loading from Module", async () => {
+    const sdk = new XLRSDK();
+    await sdk.loadDefinitionsFromModule(
+      ReferenceAssetsWebPluginManifest,
+      EXCLUDE,
+    );
+    await sdk.loadDefinitionsFromModule(Types);
+
+    expect(sdk.hasType("Asset")).toStrictEqual(true);
+    expect(sdk.hasType("AssetWrapper")).toStrictEqual(true);
+    expect(sdk.hasType("Binding")).toStrictEqual(true);
+    expect(sdk.hasType("BindingRef")).toStrictEqual(true);
+    expect(sdk.hasType("ExpressionRef")).toStrictEqual(true);
+    expect(sdk.hasType("ActionAsset")).toStrictEqual(true);
+    expect(sdk.hasType("InputAsset")).toStrictEqual(true);
+    expect(sdk.hasType("TransformedAction")).toStrictEqual(false);
+    expect(sdk.hasType("TransformedInput")).toStrictEqual(false);
+  });
+});
+
+describe("Object Recall", () => {
+  test("Raw", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    expect(sdk.getType("InputAsset", { getRawType: true })).toMatchSnapshot();
+  });
+
+  test("Processed", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    expect(sdk.getType("InputAsset", { optimize: false })).toMatchSnapshot();
+  });
+
+  test("Optimized", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    expect(sdk.getType("InputAsset")).toMatchSnapshot();
+  });
+
+  test("Test Correct Generic Cascading", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+    const Flow = sdk.getType("Flow") as ObjectType;
+    const Schema = Flow.properties["schema"].node as ObjectType;
+    const Node = Schema.additionalProperties as ObjectType;
+    const DataTypes = Node.additionalProperties as OrType;
+    const DataType = DataTypes.or[0] as ObjectType;
+    const df = DataType.properties["default"].node;
+    expect(df.type).toBe("unknown");
+  });
+});
+
+describe("Validation", () => {
+  test("Basic Validation By Name", () => {
+    const mockAsset = parseTree(`
+    {
+      "id": 1,
+      "type": "input",
+      "binding": "some.data",
+      "label": {
+        "asset": {
+          "value": "{{input.label}}"
+        }
+      }
+    `);
+
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    expect(sdk.validateByName("InputAsset", mockAsset)).toMatchSnapshot();
+  });
+
+  test("Basic Validation By Type (unoptimized)", () => {
+    const mockAsset = parseTree(`
+    {
+      "id": 1,
+      "type": "input",
+      "binding": "some.data",
+      "label": {
+        "asset": {
+          "value": "{{input.label}}"
+        }
+      }
+    `);
+
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    const inputAsset = sdk.getType("InputAsset", { optimize: false });
+    expect(inputAsset).toBeDefined();
+    expect(
+      sdk.validateByType(inputAsset as NamedType, mockAsset),
+    ).toMatchSnapshot();
+  });
+
+  test("Basic Validation By Type (optimized)", () => {
+    const mockAsset = parseTree(`
+    {
+      "id": 1,
+      "type": "input",
+      "binding": "some.data",
+      "label": {
+        "asset": {
+          "value": "{{input.label}}"
+        }
+      }
+    `);
+
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    const inputAsset = sdk.getType("InputAsset");
+    expect(inputAsset).toBeDefined();
+    expect(
+      sdk.validateByType(inputAsset as NamedType, mockAsset),
+    ).toMatchSnapshot();
+  });
+});
+
+describe("Or Type Validation", () => {
+  test("Outputs helpful type error messages", () => {
+    const mockAsset = parseTree(`
+    {
+      "type": "string",
+      "value": "orange"
+    }`);
+
+    const orType: OrType = {
+      type: "or",
+      or: [
+        { type: "string", const: "apple" },
+        { type: "string", const: "banana" },
+        { type: "string", const: "carrot" },
+        { type: "string", const: "deli-meat" },
+      ],
+    };
+
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+
+    const validator = new XLRValidator(sdk.getType);
+    let validationResult: ValidationMessage[];
+
+    if (mockAsset.children && mockAsset.children.length > 0) {
+      validationResult = validator.validateType(mockAsset.children[0], orType);
+    } else {
+      validationResult = [];
+    }
+
+    // Expected error and info messages
+    expect(validationResult).toHaveLength(2);
+    expect(validationResult[0].message).toBe(
+      "Does not match any of the types: string | string | string | string",
+    );
+    expect(validationResult[1].message).toBe(
+      "Expected: apple | banana | carrot | deli-meat",
+    );
+  });
+});
+
+describe("generateNestedTypesInfo Test", () => {
+  test("Test with potentialTypeErrors", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+    const validator = new XLRValidator(sdk.getType);
+
+    const potentialTypeErrors = [
+      {
+        type: { type: "string" },
+        errors: [
+          {
+            type: "type",
+            node: {} as any,
+            message: "Expected string",
+            severity: 1,
+            expected: "string",
+          },
+        ],
+      },
+    ];
+
+    const xlrNode = {
+      type: "or",
+      or: [{ type: "string" }, { type: "number" }],
+    } as OrType;
+
+    const rootNode = {
+      type: "boolean",
+      value: true,
+    } as any;
+
+    const result = (validator as any).generateNestedTypesInfo(
+      potentialTypeErrors,
+      xlrNode,
+      rootNode,
+    );
+
+    expect(result.nestedTypesList).toBe("string");
+    expect(result.infoMessage).toBe("Got: true and expected: string");
+  });
+
+  test("Works with urlMapping", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+    const validator = new XLRValidator(sdk.getType, {
+      urlMapping: {
+        MyType: "https://example.com/mytype",
+      },
+    });
+
+    const potentialTypeErrors: any[] = [];
+
+    const xlrNode = {
+      type: "or",
+      name: "MyType",
+      or: [{ type: "string" }, { type: "number" }],
+    } as OrType;
+
+    const rootNode = {
+      type: "boolean",
+      value: true,
+    } as any;
+
+    const result = (validator as any).generateNestedTypesInfo(
+      potentialTypeErrors,
+      xlrNode,
+      rootNode,
+    );
+
+    expect(result.nestedTypesList).toBe("https://example.com/mytype");
+    expect(result.infoMessage).toBe(
+      "Got: true and expected: https://example.com/mytype",
+    );
+  });
+
+  test("Without rootNode value", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+    const validator = new XLRValidator(sdk.getType);
+
+    const potentialTypeErrors: any[] = [];
+
+    const xlrNode = {
+      type: "or",
+      or: [{ type: "string" }, { type: "number" }],
+    } as OrType;
+
+    const rootNode = {
+      type: "boolean",
+    } as any;
+
+    const result = (validator as any).generateNestedTypesInfo(
+      potentialTypeErrors,
+      xlrNode,
+      rootNode,
+    );
+
+    expect(result.nestedTypesList).toBe("string | number");
+    expect(result.infoMessage).toBe("Expected: string | number");
+  });
+});

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./sdk";
+export * from "./types";
+export * from "./registry";
+export * from "./utils";

package/src/registry/basic-registry.ts

@@ -0,0 +1,82 @@
+import type { NamedType, NodeType } from "@xlr-lib/xlr";
+import type { XLRRegistry, Filters, TypeMetadata } from "./types";
+
+/**
+ * Basic example of a XLRs Registry
+ */
+export class BasicXLRRegistry implements XLRRegistry {
+  private typeMap: Map<string, NamedType<NodeType>>;
+  private pluginMap: Map<string, Map<string, Array<string>>>;
+  private infoMap: Map<string, TypeMetadata>;
+
+  constructor() {
+    this.typeMap = new Map();
+    this.pluginMap = new Map();
+    this.infoMap = new Map();
+  }
+
+  /** Returns a copy of the XLR to guard against unexpected type modification */
+  get(id: string): NamedType<NodeType> | undefined {
+    const value = this.typeMap.get(id);
+    return value ? JSON.parse(JSON.stringify(value)) : undefined;
+  }
+
+  add(type: NamedType<NodeType>, plugin: string, capability: string): void {
+    this.typeMap.set(type.name, type);
+    this.infoMap.set(type.name, { plugin, capability });
+
+    if (!this.pluginMap.has(plugin)) {
+      this.pluginMap.set(plugin, new Map());
+    }
+
+    const pluginsCapabilities = this.pluginMap.get(plugin) as Map<
+      string,
+      Array<string>
+    >;
+
+    if (!pluginsCapabilities.has(capability)) {
+      pluginsCapabilities.set(capability, []);
+    }
+
+    const providedCapabilities = pluginsCapabilities.get(
+      capability,
+    ) as string[];
+    providedCapabilities.push(type.name);
+  }
+
+  has(id: string): boolean {
+    return this.typeMap.has(id);
+  }
+
+  list(filterArgs?: Filters): NamedType<NodeType>[] {
+    const validTypes: Array<string> = [];
+
+    this.pluginMap.forEach((manifest, pluginName) => {
+      if (
+        !filterArgs?.pluginFilter ||
+        !pluginName.match(filterArgs.pluginFilter)
+      ) {
+        manifest.forEach((types, capabilityName) => {
+          if (
+            !filterArgs?.capabilityFilter ||
+            !capabilityName.match(filterArgs.capabilityFilter)
+          ) {
+            types.forEach((type) => {
+              if (
+                !filterArgs?.typeFilter ||
+                !type.match(filterArgs.typeFilter)
+              ) {
+                validTypes.push(type);
+              }
+            });
+          }
+        });
+      }
+    });
+    return validTypes.map((type) => this.get(type) as NamedType);
+  }
+
+  info(id: string): TypeMetadata | undefined {
+    return this.infoMap.get(id);
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1,2 @@
+export * from "./basic-registry";
+export * from "./types";

package/src/registry/types.ts

@@ -0,0 +1,28 @@
+import type { NamedType } from "@xlr-lib/xlr";
+
+export interface Filters {
+  /** filter based on plugin name */
+  pluginFilter?: string | RegExp;
+
+  /** filter based on capability name */
+  capabilityFilter?: string | RegExp;
+
+  /** filter based on type name */
+  typeFilter?: string | RegExp;
+}
+
+export interface TypeMetadata {
+  /** The Plugin the Type comes from */
+  plugin: string;
+
+  /** The Capability of the Type */
+  capability: string;
+}
+
+export interface XLRRegistry {
+  get(id: string): NamedType | undefined;
+  add(type: NamedType, from: string, capability: string): void;
+  has(id: string): boolean;
+  list(filterArgs?: Filters): Array<NamedType>;
+  info(id: string): TypeMetadata | undefined;
+}