@imbricate/core 3.7.2 → 3.8.0

package/src/document/property/triage-manager.ts

@@ -0,0 +1,68 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage Manager
+ */
+
+import { DocumentProperties, DocumentPropertyKey } from "../property";
+import { ImbricateDocumentPropertyTriageBase } from "./triage-base";
+
+export class ImbricateDocumentPropertyTriageManager<Result> extends ImbricateDocumentPropertyTriageBase<Result> {
+
+    public static create<Result>(
+        properties: DocumentProperties,
+    ): ImbricateDocumentPropertyTriageManager<Result> {
+
+        return new ImbricateDocumentPropertyTriageManager<Result>(properties);
+    }
+
+    private readonly _properties: DocumentProperties;
+
+    private constructor(
+        properties: DocumentProperties,
+    ) {
+
+        super();
+        this._properties = properties;
+    }
+
+    /**
+     * Collect the result as array
+     * 
+     * @returns collected result as array
+     */
+    public collectAsArray(): Result[] {
+
+        const result: Map<DocumentPropertyKey, Result> = super._collect(this._properties);
+        return Array.from(result.values());
+    }
+
+    /**
+     * Collect the result as map
+     * 
+     * @returns collected result as map
+     */
+    public collectAsMap(): Map<DocumentPropertyKey, Result> {
+
+        return super._collect(this._properties);
+    }
+
+    /**
+     * Collect the result as object
+     * 
+     * @returns collected result as object
+     */
+    public collectAsObject(): Record<DocumentPropertyKey, Result> {
+
+        const result: Map<DocumentPropertyKey, Result> = super._collect(this._properties);
+        const keys: DocumentPropertyKey[] = Array.from(result.keys());
+
+        const object: Record<DocumentPropertyKey, Result> = {} as Record<DocumentPropertyKey, Result>;
+        for (const key of keys) {
+
+            object[key] = result.get(key) as Result;
+        }
+
+        return object;
+    }
+}

package/src/document/property/triage.ts

@@ -0,0 +1,15 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage
+ */
+
+import { DocumentProperties } from "../property";
+import { ImbricateDocumentPropertyTriageManager } from "./triage-manager";
+
+export const triageImbricateDocumentProperties = <Result>(
+    properties: DocumentProperties,
+): ImbricateDocumentPropertyTriageManager<Result> => {
+
+    return ImbricateDocumentPropertyTriageManager.create<Result>(properties);
+};

package/{document/property.d.ts → src/document/property.ts}

@@ -3,10 +3,12 @@
  * @namespace Document
  * @description Property
  */
+
 /**
  * Document properties
  */
-export declare enum IMBRICATE_PROPERTY_TYPE {
+export enum IMBRICATE_PROPERTY_TYPE {
+
     /**
      * BOOLEAN - boolean, store as boolean
      */
@@ -46,26 +48,43 @@ export declare enum IMBRICATE_PROPERTY_TYPE {
      * REFERENCE - reference, store as a list of other document unique identifier
      *  Note: Reference is always stored as an array, even if it is a single reference
      */
-    REFERENCE = "REFERENCE"
+    REFERENCE = "REFERENCE",
 }
+
 /**
  * Document properties
- *
+ * 
  * Key - Property key, which should match schema properties unique identifier
  * Value - Property value, which should match schema properties type
  */
 export type DocumentProperties = Record<DocumentPropertyKey, DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>>;
+
 /**
  * Document property key, which should match schema properties unique identifier
  */
 export type DocumentPropertyKey = string;
 export type DocumentPropertyValue<T extends IMBRICATE_PROPERTY_TYPE> = {
+
     readonly type: T;
     readonly value: DocumentPropertyValueObject<T>;
 };
+
 export type DocumentPropertyValueObjectReference = {
+
     readonly originUniqueIdentifier: string;
     readonly databaseUniqueIdentifier: string;
     readonly documentUniqueIdentifier: string;
 };
-export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean : T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string : T extends IMBRICATE_PROPERTY_TYPE.JSON ? string : T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? string : T extends IMBRICATE_PROPERTY_TYPE.DATE ? string : T extends IMBRICATE_PROPERTY_TYPE.LABEL ? string[] : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? DocumentPropertyValueObjectReference[] : never;
+
+// IMBRICATE_PROPERTY_TYPE SWITCH
+export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> =
+    T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean :
+    T extends IMBRICATE_PROPERTY_TYPE.STRING ? string :
+    T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number :
+    T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string :
+    T extends IMBRICATE_PROPERTY_TYPE.JSON ? string :
+    T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? string :
+    T extends IMBRICATE_PROPERTY_TYPE.DATE ? string :
+    T extends IMBRICATE_PROPERTY_TYPE.LABEL ? string[] :
+    T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? DocumentPropertyValueObjectReference[] :
+    never;

package/{document/validate.js → src/document/validate.ts}

@@ -1,93 +1,105 @@
-"use strict";
 /**
  * @author WMXPY
  * @namespace Document
  * @description Validate
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateImbricateProperties = void 0;
-const property_1 = require("./property");
+
+import { ImbricateDatabaseSchema, ImbricateDatabaseSchemaProperty } from "../database/schema";
+import { DocumentProperties, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
+
 /**
  * Validate properties with schema
- *
+ * 
  * @param properties properties to validate
  * @param schema database schema to validate
  * @param allowExtraProperties allow extra properties, optional with default false
- *
+ * 
  * @returns a string error message if validation failed
  *        null if validation passed
  */
-const validateImbricateProperties = (properties, schema, allowExtraProperties = false) => {
+export const validateImbricateProperties = (
+    properties: DocumentProperties,
+    schema: ImbricateDatabaseSchema,
+    allowExtraProperties: boolean = false,
+): string | null => {
+
     if (typeof properties !== "object") {
         return "Properties must be an object";
     }
-    const keys = Object.keys(properties);
+
+    const keys: string[] = Object.keys(properties);
     for (const key of keys) {
-        const property = schema.properties.find((each) => {
+
+        const property = schema.properties.find((each: ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>) => {
             return each.propertyIdentifier === key;
         });
+
         if (!property) {
             if (allowExtraProperties) {
                 continue;
             }
             return `Property ${key} not found in schema`;
         }
-        const value = properties[key];
+
+        const value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE> = properties[key];
         if (typeof value.type !== "string") {
             return `Property ${key} type must be a string`;
         }
+
         if (value.type !== property.propertyType) {
             return `Property ${key} type must be ${property.propertyType}, but got ${value.type}`;
         }
+
         // IMBRICATE_PROPERTY_TYPE SWITCH
         switch (value.type) {
-            case property_1.IMBRICATE_PROPERTY_TYPE.BOOLEAN: {
+
+            case IMBRICATE_PROPERTY_TYPE.BOOLEAN: {
                 if (typeof value.value !== "boolean") {
                     return `Property ${key} value must be a boolean`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.STRING: {
+            case IMBRICATE_PROPERTY_TYPE.STRING: {
                 if (typeof value.value !== "string") {
                     return `Property ${key} value must be a string`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.NUMBER: {
+            case IMBRICATE_PROPERTY_TYPE.NUMBER: {
                 if (typeof value.value !== "number") {
                     return `Property ${key} value must be a number`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.MARKDOWN: {
+            case IMBRICATE_PROPERTY_TYPE.MARKDOWN: {
                 if (typeof value.value !== "string") {
                     return `Property ${key} value must be a string of text object reference`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.JSON: {
+            case IMBRICATE_PROPERTY_TYPE.JSON: {
                 if (typeof value.value !== "string") {
                     return `Property ${key} value must be a string of text object reference`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: {
+            case IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: {
                 if (typeof value.value !== "string") {
                     return `Property ${key} value must be a string of text object reference`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.DATE: {
+            case IMBRICATE_PROPERTY_TYPE.DATE: {
                 if (typeof value.value !== "string") {
                     return `Property ${key} value must be a string of date in ISO format`;
                 }
-                const date = new Date(value.value);
+                const date: Date = new Date(value.value);
                 if (isNaN(date.getTime())) {
                     return `Property ${key} value must be a string of date in ISO format`;
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.LABEL: {
+            case IMBRICATE_PROPERTY_TYPE.LABEL: {
                 if (!Array.isArray(value.value)) {
                     return `Property ${key} value must be an array of string`;
                 }
@@ -98,7 +110,7 @@ const validateImbricateProperties = (properties, schema, allowExtraProperties =
                 }
                 break;
             }
-            case property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: {
+            case IMBRICATE_PROPERTY_TYPE.REFERENCE: {
                 if (!Array.isArray(value.value)) {
                     return `Property ${key} value must be an array of string`;
                 }
@@ -120,6 +132,6 @@ const validateImbricateProperties = (properties, schema, allowExtraProperties =
             }
         }
     }
+
     return null;
 };
-exports.validateImbricateProperties = validateImbricateProperties;

package/{index.d.ts → src/index.ts}

@@ -2,11 +2,13 @@
  * @author WMXPY
  * @description Index
  */
+
 export * from "./author/definition";
 export * from "./database/definition";
 export * from "./database/interface";
 export * from "./database/manager";
 export * from "./database/schema";
+export * from "./database/validate";
 export * from "./document/definition";
 export * from "./document/interface";
 export * from "./document/property";
@@ -28,3 +30,4 @@ export * from "./static/manager";
 export * from "./text/definition";
 export * from "./text/interface";
 export * from "./text/manager";
+

package/{loader/definition.d.ts → src/loader/definition.ts}

@@ -3,6 +3,10 @@
  * @namespace Loader
  * @description Definition
  */
+
 import { OriginPayload } from "../origin/definition";
 import { IImbricateOrigin } from "../origin/interface";
-export type ImbricateOriginLoader = (payload: OriginPayload) => IImbricateOrigin;
+
+export type ImbricateOriginLoader = (
+    payload: OriginPayload,
+) => IImbricateOrigin;

package/src/loader/origin-loader.ts

@@ -0,0 +1,88 @@
+/**
+ * @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/{loader/persistence.d.ts → src/loader/persistence.ts}

@@ -3,23 +3,32 @@
  * @namespace Loader
  * @description Persistence
  */
+
 import { OriginPayload } from "../origin/definition";
+
 /**
  * Imbricate Origin Load Type
- *
+ * 
  * NPM_PACKAGE - load origin from npm package, as package name
  * FILE_SYSTEM - load origin from file system, as file path
  */
-export declare enum IMBRICATE_ORIGIN_LOAD_TYPE {
+export enum IMBRICATE_ORIGIN_LOAD_TYPE {
+
     NPM_PACKAGE = "NPM_PACKAGE",
-    FILE_SYSTEM = "FILE_SYSTEM"
+    FILE_SYSTEM = "FILE_SYSTEM",
 }
+
 export type ImbricateOriginPersistenceOrigin = {
+
     readonly originLoadType: IMBRICATE_ORIGIN_LOAD_TYPE;
     readonly originLoadValue: string;
+
     readonly originName: string;
+
     readonly originPayloads: OriginPayload;
 };
+
 export type ImbricateOriginPersistence = {
+
     readonly origins: ImbricateOriginPersistenceOrigin[];
 };

package/{origin/definition.d.ts → src/origin/definition.ts}

@@ -3,4 +3,5 @@
  * @namespace Origin
  * @description Definition
  */
+
 export type OriginPayload = Record<string, any>;

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

@@ -3,55 +3,66 @@
  * @namespace Origin
  * @description Interface
  */
+
 import { IImbricateDatabaseManager } from "../database/manager";
 import { IImbricateStaticManager } from "../static/manager";
 import { IImbricateTextManager } from "../text/manager";
 import { OriginPayload } from "./definition";
 import { ImbricateSearchResult } from "./search";
+
 export interface IImbricateOrigin {
+
     /**
      * Unique identifier of the origin
      */
     readonly uniqueIdentifier: string;
+
     /**
      * Payloads to initialize the origin
      */
     readonly payloads: OriginPayload;
+
     /**
      * Get the database manager of the origin
-     *
+     * 
      * @returns the database manager
      */
     getDatabaseManager(): IImbricateDatabaseManager;
+
     /**
      * Get the text manager of the origin
      *  The text manager is used to manage text objects
-     *
+     * 
      * @returns the text manager
      */
     getTextManager(): IImbricateTextManager;
+
     /**
      * Get the static manager of the origin
      *  The static manager is used to manage static objects
-     *
+     * 
      * @returns the static manager
      */
     getStaticManager(): IImbricateStaticManager;
+
     /**
      * Dispose the origin, optional
      * This method will be called when the origin is no longer needed
-     *
+     * 
      * If the origin needs to dispose resources, override this method
      *  else, do not implement this method
-     *
+     * 
      * Example: close database connection, or close file system
      */
     dispose?(): PromiseLike<void>;
+
     /**
      * Search for items in the origin
-     *
+     * 
      * @param keyword the keyword to search
      * @returns the search
      */
-    search(keyword: string): PromiseLike<ImbricateSearchResult>;
+    search(
+        keyword: string,
+    ): PromiseLike<ImbricateSearchResult>;
 }

package/{origin/search.d.ts → src/origin/search.ts}

@@ -3,34 +3,48 @@
  * @namespace Origin
  * @description Search
  */
-export declare enum IMBRICATE_SEARCH_TARGET_TYPE {
+
+export enum IMBRICATE_SEARCH_TARGET_TYPE {
+
     DATABASE = "DATABASE",
     DOCUMENT = "DOCUMENT",
-    MARKDOWN = "MARKDOWN"
+    MARKDOWN = "MARKDOWN",
 }
-export type ImbricateSearchTargetSwitch<T extends IMBRICATE_SEARCH_TARGET_TYPE> = T extends IMBRICATE_SEARCH_TARGET_TYPE.DATABASE ? {
-    databaseUniqueIdentifier: string;
-} : T extends IMBRICATE_SEARCH_TARGET_TYPE.DOCUMENT ? {
-    databaseUniqueIdentifier: string;
-    documentUniqueIdentifier: string;
-} : T extends IMBRICATE_SEARCH_TARGET_TYPE.MARKDOWN ? {
-    databaseUniqueIdentifier: string;
-    documentUniqueIdentifier: string;
-    propertyUniqueIdentifier: string;
-    lineNumber: number;
-} : never;
+
+export type ImbricateSearchTargetSwitch<T extends IMBRICATE_SEARCH_TARGET_TYPE> =
+    T extends IMBRICATE_SEARCH_TARGET_TYPE.DATABASE ? {
+        databaseUniqueIdentifier: string;
+    } :
+    T extends IMBRICATE_SEARCH_TARGET_TYPE.DOCUMENT ? {
+        databaseUniqueIdentifier: string;
+        documentUniqueIdentifier: string;
+    } :
+    T extends IMBRICATE_SEARCH_TARGET_TYPE.MARKDOWN ? {
+        databaseUniqueIdentifier: string;
+        documentUniqueIdentifier: string;
+        propertyUniqueIdentifier: string;
+        lineNumber: number;
+    } :
+    never;
+
 export type ImbricateSearchTarget<T extends IMBRICATE_SEARCH_TARGET_TYPE> = {
+
     readonly type: T;
     readonly target: ImbricateSearchTargetSwitch<T>;
 };
+
 export type ImbricateSearchItem = {
+
     readonly target: ImbricateSearchTarget<IMBRICATE_SEARCH_TARGET_TYPE>;
+
     readonly primary: string;
+
     /**
      * @description Source are optional, use for source context
      */
     readonly sourceDatabaseName?: string;
     readonly sourceDocumentPrimaryKey?: string;
+
     /**
      * @description Previous are optional, use for previous context on the secondary object
      */
@@ -41,6 +55,8 @@ export type ImbricateSearchItem = {
      */
     readonly secondaryNext?: string[];
 };
+
 export type ImbricateSearchResult = {
+
     readonly items: ImbricateSearchItem[];
 };

package/{static/definition.d.ts → src/static/definition.ts}

@@ -3,8 +3,11 @@
  * @namespace Static
  * @description Definition
  */
+
 import { ImbricateAuthor } from "../author/definition";
+
 export type ImbricateStaticAuditOptions = {
+
     /**
      * Static author, this is controlled an function may vary by origin
      */

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

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

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

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

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

@@ -3,8 +3,11 @@
  * @namespace Text
  * @description Definition
  */
+
 import { ImbricateAuthor } from "../author/definition";
+
 export type ImbricateTextAuditOptions = {
+
     /**
      * Text author, this is controlled an function may vary by origin
      */