@bikky/replication 1.0.1

package/Transformers/__tests__/Replicable.Transformers.SchemaGeneratorOutput.test.js

@@ -0,0 +1,441 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BikPath } from "@bikky/path";
+import { fn } from "@vitest/spy";
+import { expect, test } from "vitest";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry";
+import { Versions } from "../../Constants/Versions";
+import { SchemaGenerator } from "../SchemaGenerator";
+import { Struct, Type } from "../../Tracking/Class";
+import { Property } from "../../Tracking/Property";
+import { Progress } from "../Progress.js";
+const localPath = BikPath.getCurrentFilepath().replace(/\.test(?:\.js|\.ts)/, ".test.data.d.ts").replace(/\\/g, "/");
+function PickOutput(test, _class, style) {
+    let parts = test.split("export");
+    let match = _class.name +
+        (style === "serialised" ? "Serialised" :
+            style === "reference" ? "SerialisedReference" :
+                style === "creation" ? "Creation" :
+                    "Definition");
+    match = (style === "reference" ? "type " : "interface ") + match;
+    for (let part of parts) {
+        if (part.includes("import") && part.includes("from")) {
+            continue;
+        }
+        if (part.includes(match)) {
+            return "export" + part;
+        }
+    }
+    return match + " not found in output";
+}
+test("@Struct with @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass = class TestClass {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestClass.prototype, "prop", void 0);
+    TestClass = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass, "definition");
+            expect(match, `Output contains ${TestClass.name}Definition`).toContain(` ${TestClass.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: string;").toContain("Prop: string | `@{${string}}`;");
+            expect(match).toContain(`
+export interface ${TestClass.name}Definition {
+\tClass: "${TestClass.name}";
+\tProp: string | \`@{\${string}}\`;
+}
+            `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with array @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass2 = class TestClass2 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, { type: String, array: true })
+    ], TestClass2.prototype, "prop", void 0);
+    TestClass2 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass2);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass2, "definition");
+            expect(match, `Output contains ${TestClass2.name}Definition`).toContain(` ${TestClass2.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: string[];").toContain("Prop: (string | `@{${string}}`)[] | `@{${string}}`;");
+            expect(match).toContain(`
+export interface ${TestClass2.name}Definition {
+\tClass: "${TestClass2.name}";
+\tProp: (string | \`@{\${string}}\`)[] | \`@{\${string}}\`;
+}
+            `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with readonly @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass3 = class TestClass3 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String, { readonly: true })
+    ], TestClass3.prototype, "prop", void 0);
+    TestClass3 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass3);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass3, "definition");
+            expect(match, `Output contains ${TestClass3.name}Definition`).toContain(` ${TestClass3.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: string;").toContain("Prop: string | `@{${string}}`;");
+            expect(match).toContain(`
+export interface ${TestClass3.name}Definition {
+\tClass: "${TestClass3.name}";
+\tProp: string | \`@{\${string}}\`;
+}           `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with readonly array @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass4 = class TestClass4 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, { type: String, array: true }, { readonly: true })
+    ], TestClass4.prototype, "prop", void 0);
+    TestClass4 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass4);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass4, "definition");
+            expect(match, `Output contains ${TestClass4.name}Definition`).toContain(` ${TestClass4.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: string[];").toContain("Prop: (string | `@{${string}}`)[] | `@{${string}}`;");
+            expect(match).toContain(`
+export interface ${TestClass4.name}Definition {
+\tClass: "${TestClass4.name}";
+\tProp: (string | \`@{\${string}}\`)[] | \`@{\${string}}\`;
+}           `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with multiple @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass5 = class TestClass5 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestClass5.prototype, "prop", void 0);
+    __decorate([
+        Property(Versions.v1_0_0, Boolean)
+    ], TestClass5.prototype, "flag", void 0);
+    TestClass5 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass5);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass5, "definition");
+            expect(match, `Output contains ${TestClass5.name}Definition`).toContain(` ${TestClass5.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: string;").toContain("Prop: string | `@{${string}}`;");
+            expect(match, "Output contains Flag").toContain("Flag");
+            expect(match, "Output contains Flag: boolean;").toContain("Flag: boolean | `@{${string}}`;");
+            expect(match).toContain(`
+export interface ${TestClass5.name}Definition {
+\tClass: "${TestClass5.name}";
+\tFlag: boolean | \`@{\${string}}\`;
+\tProp: string | \`@{\${string}}\`;
+}           `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with map @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass6 = class TestClass6 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, { type: String, mapKey: String })
+    ], TestClass6.prototype, "prop", void 0);
+    TestClass6 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass6);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass6, "definition");
+            expect(match, `Output contains ${TestClass6.name}Definition`).toContain(` ${TestClass6.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: {[key: string]: (string | `@{${string}}`)} | `@{${string}}`;")
+                .toContain("Prop: {[key: string]: (string | `@{${string}}`)} | `@{${string}}`");
+            expect(match).toContain(`
+export interface ${TestClass6.name}Definition {
+\tClass: "${TestClass6.name}";
+\tProp: {[key: string]: (string | \`@{\${string}}\`)} | \`@{\${string}}\`;
+}           `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with @Property with union type.", async () => {
+    Progress.ClearCaches();
+    let TestClass7 = class TestClass7 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, [String, Boolean])
+    ], TestClass7.prototype, "prop", void 0);
+    TestClass7 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass7);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass7, "definition");
+            expect(match, `Output contains ${TestClass7.name}Definition`).toContain(` ${TestClass7.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: boolean | string;").toContain("Prop: boolean | string | `@{${string}}`;");
+            expect(match).toContain(`
+export interface ${TestClass7.name}Definition {
+\tClass: "${TestClass7.name}";
+\tProp: boolean | string | \`@{\${string}}\`;
+}
+            `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Struct with map @Property with union types.", async () => {
+    Progress.ClearCaches();
+    let TestClass8 = class TestClass8 {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, { type: [String, Boolean], mapKey: String })
+    ], TestClass8.prototype, "prop", void 0);
+    TestClass8 = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestClass8);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let match = PickOutput(text, TestClass8, "definition");
+            expect(match, `Output contains ${TestClass8.name}Definition`).toContain(` ${TestClass8.name}Definition `);
+            expect(match, "Output contains Prop").toContain("Prop");
+            expect(match, "Output contains Prop: {[key: string]: (boolean | string | \`@{\${string}}\`)} | \`@{\${string}}\`;")
+                .toContain("Prop: {[key: string]: (boolean | string | \`@{\${string}}\`)} | \`@{\${string}}\`;");
+            expect(match).toContain(`
+export interface ${TestClass8.name}Definition {
+\tClass: "${TestClass8.name}";
+\tProp: {[key: string]: (boolean | string | \`@{\${string}}\`)} | \`@{\${string}}\`;
+}           `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});
+test("@Type with @Property initialisation.", async () => {
+    Progress.ClearCaches();
+    let TestClass9 = class TestClass9 {
+        static Reference() {
+            return [1];
+        }
+        static Dereference(obj) {
+            return 1;
+        }
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestClass9.prototype, "prop", void 0);
+    TestClass9 = __decorate([
+        Type(Versions.v1_0_0)
+    ], TestClass9);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let def = PickOutput(text, TestClass9, "definition");
+            expect(def).toContain(`
+export interface ${TestClass9.name}Definition {
+\tClass: "${TestClass9.name}";
+\tProp: string | \`@{\${string}}\`;
+}           `.trim());
+            let ser = PickOutput(text, TestClass9, "serialised");
+            expect(ser).toContain(`
+export interface ${TestClass9.name}Serialised {
+\tversion: string;
+\tprop: [ "Primitive", string ] | [ "Expression", string ];
+}           `.trim());
+            let ref = PickOutput(text, TestClass9, "reference");
+            expect(ref).toContain(`
+export type TestClass9SerialisedReference = [ string, ...(string | number)[] ];
+            `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toHaveBeenCalledOnce();
+    expect(options.write).toHaveBeenCalledOnce();
+});
+test("@Type with reference to another @Type.", async () => {
+    Progress.ClearCaches();
+    let TestClass10 = class TestClass10 {
+        static Reference() {
+            return [1];
+        }
+        static Dereference(obj) {
+            return 1;
+        }
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestClass10.prototype, "prop", void 0);
+    TestClass10 = __decorate([
+        Type(Versions.v1_0_0)
+    ], TestClass10);
+    let TestOtherClass10 = class TestOtherClass10 {
+        static Reference() {
+            return [1];
+        }
+        static Dereference(obj) {
+            return 1;
+        }
+    };
+    __decorate([
+        Property(Versions.v1_0_0, TestClass10)
+    ], TestOtherClass10.prototype, "propTwo", void 0);
+    TestOtherClass10 = __decorate([
+        Type(Versions.v1_0_0)
+    ], TestOtherClass10);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(localPath);
+            return true;
+        }),
+        write: fn((file, text) => {
+            let def1 = PickOutput(text, TestClass10, "definition");
+            expect(def1, "TestClass Definition Generated Properly").toContain(`
+export interface ${TestClass10.name}Definition {
+\tClass: "${TestClass10.name}";
+\tProp: string | \`@{\${string}}\`;
+}           `.trim());
+            let ser1 = PickOutput(text, TestClass10, "serialised");
+            expect(ser1, "TestClass Serialisation Generated Properly").toContain(`
+export interface ${TestClass10.name}Serialised {
+\tversion: string;
+\tprop: [ "Primitive", string ] | [ "Expression", string ];
+}           `.trim());
+            let ref1 = PickOutput(text, TestClass10, "reference");
+            expect(ref1, "TestClass SerialisedReference Generated Properly").toContain(`
+export type ${TestClass10.name}SerialisedReference = [ string, ...(string | number)[] ];
+            `.trim());
+            let def2 = PickOutput(text, TestOtherClass10, "definition");
+            expect(def2, "TestOtherClass Definition Generated Properly").toContain(`
+export interface ${TestOtherClass10.name}Definition {
+\tClass: "${TestOtherClass10.name}";
+\tPropTwo: ${TestClass10.name}Definition | \`@{\${string}}\`;
+}           `.trim());
+            let ser2 = PickOutput(text, TestOtherClass10, "serialised");
+            expect(ser2, "TestOtherClass Serialised uses TestClassSerialisedReference").toContain(`
+export interface ${TestOtherClass10.name}Serialised {
+\tversion: string;
+\tpropTwo: ${TestClass10.name}SerialisedReference | [ "Expression", string ];
+}           `.trim());
+            let ref2 = PickOutput(text, TestOtherClass10, "reference");
+            expect(ref2, "TestOtherClass SerialisedReference Generated Properly").toContain(`
+export type ${TestOtherClass10.name}SerialisedReference = [ string, ...(string | number)[] ];
+            `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toHaveBeenCalledOnce();
+    expect(options.write).toHaveBeenCalledOnce();
+});

package/Transformers/__tests__/Replicable.Transformers.Serialiser.test.d.ts

@@ -0,0 +1 @@
+import "../Loader.js";