@imbricate/core 3.7.3 → 3.8.0

package/src/database/schema.ts

@@ -0,0 +1,165 @@
+/**
+ * @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[];
+};
+
+// IMBRICATE_PROPERTY_TYPE SWITCH
+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 const validateImbricateSchemaProperty = (
+    property: ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>,
+): string | null => {
+
+    if (typeof property.propertyIdentifier !== "string") {
+        return "Property identifier must be a string";
+    }
+    if (typeof property.propertyName !== "string") {
+        return "Property name must be a string";
+    }
+    if (!Object.values(IMBRICATE_PROPERTY_TYPE).includes(property.propertyType)) {
+        return "Property type must be a valid type";
+    }
+
+    switch (property.propertyType) {
+
+        case IMBRICATE_PROPERTY_TYPE.REFERENCE: {
+            if (typeof property.propertyOptions !== "object") {
+                return "Property options must be an object";
+            }
+            if (typeof (property.propertyOptions as any).allowMultiple !== "boolean") {
+                return "Property options allowMultiple must be a boolean";
+            }
+            if (!Array.isArray((property.propertyOptions as any).databases)) {
+                return "Property options databases must be an array";
+            }
+            for (const database of (property.propertyOptions as any).databases) {
+                if (typeof database.originUniqueIdentifier !== "string") {
+                    return "Database originUniqueIdentifier must be a string";
+                }
+                if (typeof database.databaseUniqueIdentifier !== "string") {
+                    return "Database databaseUniqueIdentifier must be a string";
+                }
+            }
+            break;
+        }
+    }
+
+    return null;
+};
+
+/**
+ * Validate a schema
+ * 
+ * @param schema database schema to validate
+ * 
+ * @returns a string error message if validation failed
+ *    null if validation passed
+ */
+export const validateImbricateSchema = (
+    schema: ImbricateDatabaseSchema,
+): string | null => {
+
+    if (!Array.isArray(schema.properties)) {
+        return "Properties must be an array";
+    }
+
+    const propertyNames: Set<string> = new Set();
+    for (const property of schema.properties) {
+
+        const propertyValidationResult: string | null = validateImbricateSchemaProperty(property);
+        if (typeof propertyValidationResult === "string") {
+            return `Invalid property ${property.propertyName}, ${propertyValidationResult}`;
+        }
+
+        if (propertyNames.has(property.propertyName)) {
+            return `Duplicated property name ${property.propertyName}`;
+        }
+        propertyNames.add(property.propertyName);
+    }
+
+    return null;
+};

package/src/database/validate.ts

@@ -0,0 +1,77 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Validate
+ */
+
+import { ImbricateDocumentQuery } from "./definition";
+
+/**
+ * Validate imbricate document query
+ * 
+ * @param query query to validate
+ * 
+ * @returns a string error message if validation failed
+ *        null if validation passed
+ */
+export const validateImbricateDocumentQuery = (query: ImbricateDocumentQuery): string | null => {
+
+    if (typeof query !== "object") {
+        return "Query must be an object";
+    }
+
+    if (query.limit !== undefined && typeof query.limit !== "number" && query.limit <= 0) {
+        return "Limit must be a number greater than 0 or undefined";
+    }
+    if (query.skip !== undefined && typeof query.skip !== "number" && query.skip < 0) {
+        return "Skip must be a number greater than or equal to 0 or undefined";
+    }
+
+    if (query.propertyFilters !== undefined) {
+        if (!Array.isArray(query.propertyFilters)) {
+            return "Property filters must be an array";
+        }
+
+        for (const filter of query.propertyFilters) {
+
+            if (typeof filter.propertyIdentifier !== "string") {
+                return "Property identifier must be a string";
+            }
+
+            if (!Array.isArray(filter.conditions)) {
+                return "Conditions must be an array";
+            }
+
+            for (const condition of filter.conditions) {
+
+                if (typeof condition.target !== "string") {
+                    return "Target must be a string";
+                }
+                if (typeof condition.condition !== "string") {
+                    return "Condition must be a string";
+                }
+            }
+        }
+    }
+
+    if (query.annotationFilters !== undefined) {
+        if (!Array.isArray(query.annotationFilters)) {
+            return "Annotation filters must be an array";
+        }
+
+        for (const filter of query.annotationFilters) {
+
+            if (typeof filter.namespace !== "string") {
+                return "Namespace must be a string";
+            }
+            if (typeof filter.identifier !== "string") {
+                return "Identifier must be a string";
+            }
+            if (typeof filter.condition !== "string") {
+                return "Condition must be a string";
+            }
+        }
+    }
+
+    return null;
+};

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

@@ -3,48 +3,76 @@
  * @namespace Document
  * @description Definition
  */
+
 import { ImbricateAuthor } from "../author/definition";
 import { DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
+
 /**
  * Edit record type of the document
  */
-export declare enum IMBRICATE_DOCUMENT_EDIT_TYPE {
+export enum IMBRICATE_DOCUMENT_EDIT_TYPE {
+
     PUT_PROPERTY = "PUT_PROPERTY",
     PUT_ANNOTATION = "PUT_ANNOTATION",
-    DELETE_ANNOTATION = "DELETE_ANNOTATION"
+    DELETE_ANNOTATION = "DELETE_ANNOTATION",
 }
+
 export type DocumentEditOperationValuePutProperty = {
+
     readonly key: DocumentPropertyKey;
     readonly value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>;
 };
+
 export type DocumentEditOperationPutAnnotation = {
+
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
+
     readonly data: any;
 };
+
 export type DocumentEditOperationDeleteAnnotation = {
+
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
 };
-export type DocumentEditOperationValue<T extends IMBRICATE_DOCUMENT_EDIT_TYPE> = T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_PROPERTY ? DocumentEditOperationValuePutProperty : T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_ANNOTATION ? DocumentEditOperationPutAnnotation : T extends IMBRICATE_DOCUMENT_EDIT_TYPE.DELETE_ANNOTATION ? DocumentEditOperationDeleteAnnotation : never;
+
+// IMBRICATE_DOCUMENT_EDIT_TYPE SWITCH
+export type DocumentEditOperationValue<T extends IMBRICATE_DOCUMENT_EDIT_TYPE> =
+    T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_PROPERTY ? DocumentEditOperationValuePutProperty :
+    T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_ANNOTATION ? DocumentEditOperationPutAnnotation :
+    T extends IMBRICATE_DOCUMENT_EDIT_TYPE.DELETE_ANNOTATION ? DocumentEditOperationDeleteAnnotation :
+    never;
+
 export type DocumentEditOperation<T extends IMBRICATE_DOCUMENT_EDIT_TYPE> = {
+
     readonly action: T;
     readonly value: DocumentEditOperationValue<T>;
 };
+
 export type DocumentEditRecord = {
+
     readonly uniqueIdentifier: string;
     readonly editAt: Date;
+
     readonly operations: Array<DocumentEditOperation<IMBRICATE_DOCUMENT_EDIT_TYPE>>;
+
     readonly author?: ImbricateAuthor;
 };
+
 export type DocumentAnnotations = Record<DocumentAnnotationKey, DocumentAnnotationValue>;
+
 export type DocumentAnnotationKey = string;
 export type DocumentAnnotationValue = {
+
     readonly namespace: string;
     readonly identifier: string;
+
     readonly data: any;
 };
+
 export type ImbricateDocumentAuditOptions = {
+
     /**
      * Do not add edit record, this is controlled an function may vary by origin
      */

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

@@ -3,84 +3,113 @@
  * @namespace Document
  * @description Interface
  */
+
 import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "./definition";
 import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
+
 export interface IImbricateDocument {
+
     /**
      * Unique identifier of the database
      */
     readonly uniqueIdentifier: string;
+
     /**
      * Properties of the document
      */
     readonly properties: DocumentProperties;
+
     /**
      * Annotations of the database
      */
     readonly annotations: DocumentAnnotations;
+
     /**
      * Update a property from the document
-     *
+     * 
      * @param key key of the property
      * @param value value of the property
      * @param auditOptions audit options of the document
-     *
+     * 
      * @returns a promise of the edit records of the document
      *  Note: the edit records will not be added to the document if `noEditRecord` is true,
      *  Call `addEditRecords` to add the edit records manually.
      */
-    putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putProperty(
+        key: DocumentPropertyKey,
+        value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>,
+        auditOptions?: ImbricateDocumentAuditOptions,
+    ): PromiseLike<DocumentEditRecord[]>;
+
     /**
      * Put and replace all properties of the document
-     *
+     * 
      * @param properties properties of the document
      * @param auditOptions audit options of the document
-     *
+     * 
      * @returns a promise of the edit records of the document
      *  Note: the edit records will not be added to the document if `noEditRecord` is true,
      *  Call `addEditRecords` to add the edit records manually.
      */
-    putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putProperties(
+        properties: DocumentProperties,
+        auditOptions?: ImbricateDocumentAuditOptions,
+    ): PromiseLike<DocumentEditRecord[]>;
+
     /**
      * put annotation to the document
-     *
+     * 
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param value value of the annotation
      * @param auditOptions audit options of the document
-     *
+     * 
      * @returns a promise of the edit records of the document
      *  Note: if the origin supports Document Edit Record, the edit record will be added by default
      *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
      */
-    putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putAnnotation(
+        namespace: string,
+        identifier: string,
+        value: DocumentAnnotationValue,
+        auditOptions?: ImbricateDocumentAuditOptions,
+    ): PromiseLike<DocumentEditRecord[]>;
+
     /**
      * Delete annotation from the document
-     *
+     * 
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param auditOptions audit options of the document
-     *
+     * 
      * @returns a promise of the edit records of the document
      *  Note: if the origin supports Document Edit Record, the edit record will be added by default
      *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
      */
-    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    deleteAnnotation(
+        namespace: string,
+        identifier: string,
+        auditOptions?: ImbricateDocumentAuditOptions,
+    ): PromiseLike<DocumentEditRecord[]>;
+
     /**
      * Add edit records to the document, optional
      *  This method is optional, if not implemented, means the origin
      *  1. The origin does not support edit records
      *  2. The origin force to add edit records when put properties
-     *
+     * 
      * @param records document edit records
      */
-    addEditRecords?(records: DocumentEditRecord[]): PromiseLike<void>;
+    addEditRecords?(
+        records: DocumentEditRecord[],
+    ): PromiseLike<void>;
+
     /**
      * Get edit records of the document, optional
      *  This method is optional, if not implemented, means the origin
      *  1. The origin does not support edit records
      *  2. The origin force to add edit records when put properties
-     *
+     * 
      * @returns a promise of the edit records of the document
      */
     getEditRecords?(): PromiseLike<DocumentEditRecord[]>;

package/src/document/property/default-value.ts

@@ -0,0 +1,26 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Default Value
+ */
+
+import { DocumentPropertyValueObject, IMBRICATE_PROPERTY_TYPE } from "../property";
+
+// IMBRICATE_PROPERTY_TYPE SWITCH
+export const getImbricateDefaultValueOfProperty = (type: IMBRICATE_PROPERTY_TYPE): DocumentPropertyValueObject<IMBRICATE_PROPERTY_TYPE> => {
+
+    switch (type) {
+
+        case IMBRICATE_PROPERTY_TYPE.BOOLEAN: return false;
+        case IMBRICATE_PROPERTY_TYPE.STRING: return "";
+        case IMBRICATE_PROPERTY_TYPE.NUMBER: return 0;
+        case IMBRICATE_PROPERTY_TYPE.MARKDOWN: return "";
+        case IMBRICATE_PROPERTY_TYPE.JSON: return "";
+        case IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: return "";
+        case IMBRICATE_PROPERTY_TYPE.DATE: return new Date().toISOString();
+        case IMBRICATE_PROPERTY_TYPE.LABEL: return [];
+        case IMBRICATE_PROPERTY_TYPE.REFERENCE: return [];
+    }
+
+    return null as any;
+};

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

@@ -3,5 +3,10 @@
  * @namespace Document_Property
  * @description Definition
  */
+
 import { DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
-export type DocumentPropertyTriageFunction<T extends IMBRICATE_PROPERTY_TYPE, Result> = (propertyKey: DocumentPropertyKey, value: DocumentPropertyValue<T>) => Result;
+
+export type DocumentPropertyTriageFunction<T extends IMBRICATE_PROPERTY_TYPE, Result> = (
+    propertyKey: DocumentPropertyKey,
+    value: DocumentPropertyValue<T>
+) => Result;

package/src/document/property/primary.ts

@@ -0,0 +1,29 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Primary
+ */
+
+import { ImbricateDatabaseSchema } from "../../database/schema";
+import { DocumentProperties, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+
+export const findPrimaryProperty = (
+    schema: ImbricateDatabaseSchema,
+    properties: DocumentProperties,
+): DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE> | null => {
+
+    for (const property of schema.properties) {
+
+        if (property.isPrimaryKey) {
+
+            const value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE> | undefined =
+                properties[property.propertyIdentifier];
+
+            if (value) {
+                return value;
+            }
+        }
+    }
+
+    return null;
+};

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

@@ -0,0 +1,138 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage Base
+ */
+
+import { DocumentProperties, DocumentPropertyKey, IMBRICATE_PROPERTY_TYPE } from "../property";
+import { DocumentPropertyTriageFunction } from "./definition";
+
+// IMBRICATE_PROPERTY_TYPE SWITCH
+export class ImbricateDocumentPropertyTriageBase<Result> {
+
+    private readonly _triageFunctionsByKey: Map<string, DocumentPropertyTriageFunction<any, Result>>;
+    private readonly _triageFunctionsByType: Map<IMBRICATE_PROPERTY_TYPE, DocumentPropertyTriageFunction<any, Result>>;
+
+    protected constructor() {
+
+        this._triageFunctionsByKey = new Map();
+        this._triageFunctionsByType = new Map();
+    }
+
+    /**
+     * Set triage function for property key,
+     *  This action will override document value based triage functions
+     * 
+     * @param propertyKey property key
+     * @param triageFunction triage function
+     * @returns triage manager
+     */
+    public forPropertyKey<T extends IMBRICATE_PROPERTY_TYPE>(
+        propertyKey: DocumentPropertyKey,
+        triageFunction: DocumentPropertyTriageFunction<T, Result>,
+    ): this {
+
+        this._triageFunctionsByKey.set(propertyKey, triageFunction);
+        return this;
+    }
+
+    public forBoolean(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.BOOLEAN, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.BOOLEAN, triageFunction);
+        return this;
+    }
+
+    public forString(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.STRING, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.STRING, triageFunction);
+        return this;
+    }
+
+    public forNumber(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.NUMBER, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.NUMBER, triageFunction);
+        return this;
+    }
+
+    public forMarkdown(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.MARKDOWN, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.MARKDOWN, triageFunction);
+        return this;
+    }
+
+    public forJson(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.JSON, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.JSON, triageFunction);
+        return this;
+    }
+
+    public forImbriscript(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT, triageFunction);
+        return this;
+    }
+
+    public forDate(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.DATE, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.DATE, triageFunction);
+        return this;
+    }
+
+    public forLabel(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.LABEL, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.LABEL, triageFunction);
+        return this;
+    }
+
+    public forReference(
+        triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.REFERENCE, Result>,
+    ): this {
+
+        this._triageFunctionsByType.set(IMBRICATE_PROPERTY_TYPE.REFERENCE, triageFunction);
+        return this;
+    }
+
+    protected _collect(properties: DocumentProperties): Map<DocumentPropertyKey, Result> {
+
+        const keys: DocumentPropertyKey[] = Object.keys(properties);
+        const result: Map<DocumentPropertyKey, Result> = new Map();
+        for (const key of keys) {
+
+            const property = properties[key];
+            const triageFunction = this._triageFunctionsByKey.get(key);
+
+            if (typeof triageFunction === "function") {
+
+                const value: Result = triageFunction(key, property);
+                result.set(key, value);
+                continue;
+            }
+
+            const typeFunction = this._triageFunctionsByType.get(property.type);
+            if (typeof typeFunction === "function") {
+
+                const value: Result = typeFunction(key, property);
+                result.set(key, value);
+                continue;
+            }
+        }
+
+        return result;
+    }
+}