@imbricate/core 3.8.0 → 3.8.2

package/src/loader/origin-loader.ts

@@ -1,88 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Loader
- * @description Origin Loader
- */
-
-import { IImbricateOrigin } from "../origin/interface";
-import { IMBRICATE_ORIGIN_LOAD_TYPE, ImbricateOriginPersistence, ImbricateOriginPersistenceOrigin } from "./persistence";
-
-/**
- * Load imbricate origin from persistence origin
- *  This function will load the origin from the persistence origin
- *  and initialize the origin with the payloads
- * 
- * @param origin origin to persistence to load
- * 
- * @returns a promise of the loaded origin
- *  if the origin is not found, return null
- */
-export const loadImbricateOriginFromPersistenceOrigin = async (
-    origin: ImbricateOriginPersistenceOrigin,
-): Promise<IImbricateOrigin | null> => {
-
-    switch (origin.originLoadType) {
-
-        case IMBRICATE_ORIGIN_LOAD_TYPE.NPM_PACKAGE: {
-
-            const originPackage = await import(origin.originLoadValue);
-
-            if (typeof originPackage.default === "function") {
-
-                const initialized = originPackage.default.call(
-                    null,
-                    origin.originPayloads,
-                );
-
-                return initialized;
-            }
-            break;
-        }
-
-        case IMBRICATE_ORIGIN_LOAD_TYPE.FILE_SYSTEM: {
-
-            const originPackage = await import(origin.originLoadValue);
-
-            if (typeof originPackage.default === "function") {
-
-                const initialized = originPackage.default.call(
-                    null,
-                    origin.originPayloads,
-                );
-
-                return initialized;
-            }
-            break;
-        }
-    }
-
-    return null;
-};
-
-/**
- * Load imbricate origins from persistence
- *  This function will load all origins from the persistence
- *  and initialize the origins with the payloads
- *  If the origin is not found, it will be ignored
- * 
- * @param persistence persistence to load origins
- *  
- * @returns a promise of the loaded origins, if the origin is not found, return empty array
- */
-export const loadImbricateOriginsFromPersistence = async (
-    persistence: ImbricateOriginPersistence,
-): Promise<IImbricateOrigin[]> => {
-
-    const origins: IImbricateOrigin[] = [];
-
-    for (const origin of persistence.origins) {
-
-        const originInstance: IImbricateOrigin | null = await loadImbricateOriginFromPersistenceOrigin(origin);
-
-        if (originInstance) {
-            origins.push(originInstance);
-        }
-    }
-
-    return origins;
-};

package/test/unit/database/schema.test.ts

@@ -1,95 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Database
- * @description Schema
- * @override Unit Test
- */
-
-import { validateImbricateSchema } from "../../../src/database/schema";
-import { IMBRICATE_PROPERTY_TYPE } from "../../../src/document/property";
-
-describe("Given [Database Schema] methods", (): void => {
-
-    test("should be able to validate schema", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateSchema(testSchema);
-
-        expect(result).toBeNull();
-    });
-
-    test("should be able to invalidate schema - properties not array", (): void => {
-
-        const testSchema: any = {
-            properties: "test",
-        };
-
-        const result: string | null = validateImbricateSchema(testSchema);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate schema - invalid property", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateSchema(testSchema);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate schema - invalid property type", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: "INVALID",
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateSchema(testSchema);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate schema - duplicate property name", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateSchema(testSchema);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-});

package/test/unit/document/property/primary.test.ts

@@ -1,87 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Primary
- * @override Unit Test
- */
-
-import { DocumentProperties, IMBRICATE_PROPERTY_TYPE, ImbricateDatabaseSchema, findPrimaryProperty } from "../../../../src";
-
-describe("Given [Document-Property-Primary] helper methods", (): void => {
-
-    it("should be able to find primary property", (): void => {
-
-        const schema: ImbricateDatabaseSchema = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                    propertyOptions: {},
-                    isPrimaryKey: true,
-                },
-            ],
-        };
-
-        const properties: DocumentProperties = {
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-        };
-
-        const result = findPrimaryProperty(schema, properties);
-
-        expect(result).toStrictEqual({
-            type: IMBRICATE_PROPERTY_TYPE.STRING,
-            value: "test",
-        });
-    });
-
-    it("should be able to find primary property - null", (): void => {
-
-        const schema: ImbricateDatabaseSchema = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                    propertyOptions: {},
-                    isPrimaryKey: true,
-                },
-            ],
-        };
-
-        const properties: DocumentProperties = {};
-
-        const result = findPrimaryProperty(schema, properties);
-
-        expect(result).toBeNull();
-    });
-
-    it("should be able to find primary property - not primary", (): void => {
-
-        const schema: ImbricateDatabaseSchema = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                    propertyOptions: {},
-                    isPrimaryKey: false,
-                },
-            ],
-        };
-
-        const properties: DocumentProperties = {
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-        };
-
-        const result = findPrimaryProperty(schema, properties);
-
-        expect(result).toBeNull();
-    });
-});

package/test/unit/document/property/triage.test.ts

@@ -1,64 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document_Property
- * @description Triage
- * @override Unit Test
- */
-
-import { DocumentProperties, IMBRICATE_PROPERTY_TYPE, triageImbricateDocumentProperties } from "../../../../src";
-
-describe("Given [Document-Property-Triage] helper methods", (): void => {
-
-    it("should be able to triage single property", (): void => {
-
-        const properties: DocumentProperties = {
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-        };
-
-        const result = triageImbricateDocumentProperties(properties)
-            .forString(() => "string")
-            .collectAsArray();
-
-        expect(result).toStrictEqual(["string"]);
-    });
-
-    it("should be able to triage single property - not match", (): void => {
-
-        const properties: DocumentProperties = {
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-        };
-
-        const result = triageImbricateDocumentProperties(properties)
-            .forNumber(() => "number")
-            .collectAsArray();
-
-        expect(result).toStrictEqual([]);
-    });
-
-    it("should be able to triage multiple property", (): void => {
-
-        const properties: DocumentProperties = {
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-            number: {
-                type: IMBRICATE_PROPERTY_TYPE.NUMBER,
-                value: 1,
-            },
-        };
-
-        const result = triageImbricateDocumentProperties(properties)
-            .forString(() => "string")
-            .forNumber(() => "number")
-            .collectAsArray();
-
-        expect(result).toStrictEqual(["string", "number"]);
-    });
-});

package/test/unit/document/validate.test.ts

@@ -1,138 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Document
- * @description Validate
- * @override Unit Test
- */
-
-import { IMBRICATE_PROPERTY_TYPE, validateImbricateProperties } from "../../../src";
-
-describe("Given [Document Validate] methods", (): void => {
-
-    test("should be able to validate property", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateProperties({
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-        }, testSchema as any);
-
-        expect(result).toBeNull();
-    });
-
-    test("should be able to invalidate property - not object", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateProperties("test" as any, testSchema as any);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate property - invalid property", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateProperties({
-            notExist: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: "test",
-            },
-        }, testSchema as any);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate property - invalid property type", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateProperties({
-            test: {
-                type: "INVALID" as any,
-                value: "test",
-            },
-        }, testSchema as any);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate property - invalid property value", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.STRING,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateProperties({
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: 123 as any,
-            },
-        }, testSchema as any);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-
-    test("should be able to invalidate property - invalid property value type", (): void => {
-
-        const testSchema: any = {
-            properties: [
-                {
-                    propertyIdentifier: "test",
-                    propertyName: "test",
-                    propertyType: IMBRICATE_PROPERTY_TYPE.MARKDOWN,
-                },
-            ],
-        };
-
-        const result: string | null = validateImbricateProperties({
-            test: {
-                type: IMBRICATE_PROPERTY_TYPE.STRING,
-                value: 123 as any,
-            },
-        }, testSchema as any);
-
-        expect(typeof result).toStrictEqual("string");
-    });
-});

package/test/unit/loader/definition.test.ts

@@ -1,55 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Loader
- * @description Definition
- * @override Unit Test
- */
-
-import { IMBRICATE_ORIGIN_LOAD_TYPE, loadImbricateOriginsFromPersistence } from "../../../src";
-import { ImbricateOriginLoader } from "../../../src/loader/definition";
-
-describe("Given [Origin Loader] methods", (): void => {
-
-    test("should be able to initialize npm package", async (): Promise<void> => {
-
-        let mockPayload: any;
-
-        jest.mock("mock-origin", () => {
-
-            const loader: ImbricateOriginLoader = (payload: any) => {
-
-                mockPayload = payload;
-                return {
-                    name: "Mock",
-                } as any;
-            };
-
-            return loader;
-        }, {
-            virtual: true,
-        });
-
-        const origins = await loadImbricateOriginsFromPersistence({
-            origins: [
-                {
-                    originLoadType: IMBRICATE_ORIGIN_LOAD_TYPE.NPM_PACKAGE,
-                    originLoadValue: "mock-origin",
-
-                    originName: "Mock",
-                    originPayloads: {
-                        hello: "world",
-                    },
-                },
-            ],
-        });
-
-        expect(origins).toHaveLength(1);
-        expect(mockPayload).toEqual({
-            hello: "world",
-        });
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-});

package/typescript/tsconfig.build.json

@@ -1,23 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES6",
-        "lib": [
-            "esnext"
-        ],
-        "outDir": "../app",
-        "downlevelIteration": true,
-        "declaration": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "strict": true,
-        "module": "CommonJS",
-        "moduleResolution": "node",
-        "isolatedModules": true
-    },
-    "include": [
-        "../src/**/*.ts",
-    ],
-    "exclude": [
-        "node_modules"
-    ]
-}