@imbricate/core 3.7.3 → 3.8.0

package/{text/interface.d.ts → src/text/interface.ts}

@@ -3,19 +3,24 @@
  * @namespace Text
  * @description Interface
  */
+
 import { ImbricateAuthor } from "../author/definition";
+
 export interface IImbricateText {
+
     /**
      * Unique identifier of the text object
      */
     readonly uniqueIdentifier: string;
+
     /**
      * Author of the text object
      */
     readonly author?: ImbricateAuthor;
+
     /**
      * Get the content of the text object
-     *
+     * 
      * @returns a promise of the content of the text object
      */
     getContent(): PromiseLike<string>;

package/{text/manager.d.ts → src/text/manager.ts}

@@ -3,24 +3,31 @@
  * @namespace Text
  * @description Manager
  */
+
 import { ImbricateTextAuditOptions } from "./definition";
 import { IImbricateText } from "./interface";
+
 export interface IImbricateTextManager {
+
     /**
      * Get the text object from the origin
-     *
+     * 
      * @returns a promise of the text object, null if not found
      */
     getText(uniqueIdentifier: string): PromiseLike<IImbricateText | null>;
+
     /**
      * Create a new text object in the origin
      *  Text object is immutable, once created, it cannot be changed
      *  Patch a new text object if you want to change the content
-     *
+     * 
      * @param content content of the text
      * @param auditOptions audit options of the text
-     *
+     * 
      * @returns a promise of the text object
      */
-    createText(content: string, auditOptions?: ImbricateTextAuditOptions): PromiseLike<IImbricateText>;
+    createText(
+        content: string,
+        auditOptions?: ImbricateTextAuditOptions,
+    ): PromiseLike<IImbricateText>;
 }

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+{
+    "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"
+    ]
+}

package/author/definition.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Author
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/database/definition.js

@@ -1,17 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Database
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMBRICATE_DATABASE_EDIT_TYPE = void 0;
-/**
- * Edit record type of the document
- */
-var IMBRICATE_DATABASE_EDIT_TYPE;
-(function (IMBRICATE_DATABASE_EDIT_TYPE) {
-    IMBRICATE_DATABASE_EDIT_TYPE["PUT_SCHEMA"] = "PUT_SCHEMA";
-    IMBRICATE_DATABASE_EDIT_TYPE["PUT_ANNOTATION"] = "PUT_ANNOTATION";
-    IMBRICATE_DATABASE_EDIT_TYPE["DELETE_ANNOTATION"] = "DELETE_ANNOTATION";
-})(IMBRICATE_DATABASE_EDIT_TYPE || (exports.IMBRICATE_DATABASE_EDIT_TYPE = IMBRICATE_DATABASE_EDIT_TYPE = {}));

package/database/interface.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Database
- * @description Interface
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/database/manager.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Database
- * @description Manager
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/database/schema.d.ts

@@ -1,70 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Database
- * @description Schema
- */
-import { IMBRICATE_PROPERTY_TYPE } from "../document/property";
-export type ImbricateDatabaseSchemaProperty<T extends IMBRICATE_PROPERTY_TYPE> = {
-    readonly propertyIdentifier: string;
-} & ImbricateDatabaseSchemaPropertyForCreation<T>;
-export type ImbricateDatabaseSchemaPropertyOptionsReferenceDatabase = {
-    readonly originUniqueIdentifier: string;
-    readonly databaseUniqueIdentifier: string;
-};
-export type ImbricateDatabaseSchemaPropertyOptionsLabelOption = {
-    readonly labelIdentifier: string;
-    readonly labelName: string;
-    readonly labelColor: string;
-};
-export type ImbricateDatabaseSchemaPropertyOptionsLabel = {
-    /**
-     * Allow multiple labels
-     */
-    readonly allowMultiple: boolean;
-    /**
-     * Label Options
-     */
-    readonly labelOptions: ImbricateDatabaseSchemaPropertyOptionsLabelOption[];
-};
-export type ImbricateDatabaseSchemaPropertyOptionsReference = {
-    /**
-     * Allow multiple references
-     */
-    readonly allowMultiple: boolean;
-    /**
-     * Allow references from these databases
-     *  If empty, allow references from all databases
-     */
-    readonly databases: ImbricateDatabaseSchemaPropertyOptionsReferenceDatabase[];
-};
-export type ImbricateDatabaseSchemaPropertyOptions<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? {} : T extends IMBRICATE_PROPERTY_TYPE.STRING ? {} : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? {} : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? {} : T extends IMBRICATE_PROPERTY_TYPE.JSON ? {} : T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? {} : T extends IMBRICATE_PROPERTY_TYPE.DATE ? {} : T extends IMBRICATE_PROPERTY_TYPE.LABEL ? ImbricateDatabaseSchemaPropertyOptionsLabel : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? ImbricateDatabaseSchemaPropertyOptionsReference : never;
-export type ImbricateDatabaseSchemaPropertyForCreation<T extends IMBRICATE_PROPERTY_TYPE> = {
-    readonly propertyName: string;
-    readonly propertyType: T;
-    readonly propertyOptions: ImbricateDatabaseSchemaPropertyOptions<T>;
-    readonly isPrimaryKey?: boolean;
-};
-export type ImbricateDatabaseSchema = {
-    readonly properties: Array<ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>>;
-};
-export type ImbricateDatabaseSchemaForCreation = {
-    readonly properties: Array<ImbricateDatabaseSchemaPropertyForCreation<IMBRICATE_PROPERTY_TYPE>>;
-};
-/**
- * Validate a schema property
- *
- * @param property property to validate
- *
- * @returns a string error message if validation failed
- *      null if validation passed
- */
-export declare const validateImbricateSchemaProperty: (property: ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>) => string | null;
-/**
- * Validate a schema
- *
- * @param schema database schema to validate
- *
- * @returns a string error message if validation failed
- *    null if validation passed
- */
-export declare const validateImbricateSchema: (schema: ImbricateDatabaseSchema) => string | null;