@imbricate/core 3.8.0 → 3.8.1

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

@@ -3,13 +3,9 @@
  * @namespace Author
  * @description Definition
  */
-
 export type ImbricateAuthor = {
-
     readonly category: string;
     readonly identifier: string;
-
     readonly isAutomation: boolean;
-
     readonly onBehalfOf?: ImbricateAuthor;
 };

package/author/definition.js

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

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

@@ -3,117 +3,78 @@
  * @namespace Database
  * @description Definition
  */
-
 import { ImbricateAuthor } from "../author/definition";
 import { ImbricateDatabaseSchema } from "./schema";
-
-export enum IMBRICATE_QUERY_COMPARE_CONDITION {
-
-    EQUAL = "EQUAL",
+export declare enum IMBRICATE_QUERY_COMPARE_CONDITION {
+    EQUAL = "EQUAL"
 }
-
-export enum IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET {
-
+export declare enum IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET {
     PROPERTY_TYPE = "PROPERTY_TYPE",
-    PROPERTY_VALUE = "PROPERTY_VALUE",
+    PROPERTY_VALUE = "PROPERTY_VALUE"
 }
-
 export type ImbricateDocumentQueryPropertyFilterCondition = {
-
     readonly target: IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET;
     readonly condition: IMBRICATE_QUERY_COMPARE_CONDITION;
     readonly value: any;
 };
-
 export type ImbricateDocumentQueryPropertyFilter = {
-
     readonly propertyIdentifier: string;
     readonly conditions: ImbricateDocumentQueryPropertyFilterCondition[];
 };
-
 export type ImbricateDocumentQueryAnnotationFilter = {
-
     readonly namespace: string;
     readonly identifier: string;
     readonly condition: IMBRICATE_QUERY_COMPARE_CONDITION;
     readonly value: any;
 };
-
 /**
  * Query of the document
- * 
+ *
  * @param limit limit of the query
  * @param skip skip of the query
  */
 export type ImbricateDocumentQuery = {
-
     readonly limit?: number;
     readonly skip?: number;
-
     readonly propertyFilters?: ImbricateDocumentQueryPropertyFilter[];
     readonly annotationFilters?: ImbricateDocumentQueryAnnotationFilter[];
 };
-
 /**
  * Edit record type of the document
  */
-export enum IMBRICATE_DATABASE_EDIT_TYPE {
-
+export declare enum IMBRICATE_DATABASE_EDIT_TYPE {
     PUT_SCHEMA = "PUT_SCHEMA",
     PUT_ANNOTATION = "PUT_ANNOTATION",
-    DELETE_ANNOTATION = "DELETE_ANNOTATION",
+    DELETE_ANNOTATION = "DELETE_ANNOTATION"
 }
-
 export type DatabaseEditOperationPutAnnotation = {
-
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
-
     readonly data: any;
 };
-
 export type DatabaseEditOperationDeleteAnnotation = {
-
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
 };
-
-// IMBRICATE_DATABASE_EDIT_TYPE SWITCH
-export type DatabaseEditOperationValue<T extends IMBRICATE_DATABASE_EDIT_TYPE> =
-    T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_SCHEMA ? ImbricateDatabaseSchema :
-    T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_ANNOTATION ? DatabaseEditOperationPutAnnotation :
-    T extends IMBRICATE_DATABASE_EDIT_TYPE.DELETE_ANNOTATION ? DatabaseEditOperationDeleteAnnotation :
-    never;
-
+export type DatabaseEditOperationValue<T extends IMBRICATE_DATABASE_EDIT_TYPE> = T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_SCHEMA ? ImbricateDatabaseSchema : T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_ANNOTATION ? DatabaseEditOperationPutAnnotation : T extends IMBRICATE_DATABASE_EDIT_TYPE.DELETE_ANNOTATION ? DatabaseEditOperationDeleteAnnotation : never;
 export type DatabaseEditOperation<T extends IMBRICATE_DATABASE_EDIT_TYPE> = {
-
     readonly action: T;
     readonly value: DatabaseEditOperationValue<T>;
 };
-
 export type DatabaseEditRecord = {
-
     readonly uniqueIdentifier: string;
     readonly editAt: Date;
-
     readonly operations: Array<DatabaseEditOperation<IMBRICATE_DATABASE_EDIT_TYPE>>;
-
     readonly author?: ImbricateAuthor;
 };
-
 export type DatabaseAnnotations = Record<DatabaseAnnotationKey, DatabaseAnnotationValue>;
-
 export type DatabaseAnnotationKey = string;
 export type DatabaseAnnotationValue = {
-
     readonly namespace: string;
     readonly identifier: string;
-
     readonly data: any;
 };
-
 export type ImbricateDatabaseAuditOptions = {
-
     /**
      * Do not add edit record, this is controlled an function may vary by origin
      */

package/database/definition.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMBRICATE_DATABASE_EDIT_TYPE = exports.IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET = exports.IMBRICATE_QUERY_COMPARE_CONDITION = void 0;
+var IMBRICATE_QUERY_COMPARE_CONDITION;
+(function (IMBRICATE_QUERY_COMPARE_CONDITION) {
+    IMBRICATE_QUERY_COMPARE_CONDITION["EQUAL"] = "EQUAL";
+})(IMBRICATE_QUERY_COMPARE_CONDITION || (exports.IMBRICATE_QUERY_COMPARE_CONDITION = IMBRICATE_QUERY_COMPARE_CONDITION = {}));
+var IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET;
+(function (IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET) {
+    IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET["PROPERTY_TYPE"] = "PROPERTY_TYPE";
+    IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET["PROPERTY_VALUE"] = "PROPERTY_VALUE";
+})(IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET || (exports.IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET = IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET = {}));
+/**
+ * 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/{src/database/interface.ts → database/interface.d.ts}

@@ -3,162 +3,120 @@
  * @namespace Database
  * @description Interface
  */
-
 import { IImbricateDocument } from "../document/interface";
 import { DocumentProperties } from "../document/property";
 import { DatabaseAnnotationValue, DatabaseAnnotations, DatabaseEditRecord, ImbricateDatabaseAuditOptions, ImbricateDocumentQuery } from "./definition";
 import { ImbricateDatabaseSchema } from "./schema";
-
 export interface IImbricateDatabase {
-
     /**
      * Unique identifier of the database
      */
     readonly uniqueIdentifier: string;
-
     /**
      * Name of the database
      */
     readonly databaseName: string;
-
     /**
      * Schema of the database
      */
     readonly schema: ImbricateDatabaseSchema;
-
     /**
      * Annotations of the database
      */
     readonly annotations: DatabaseAnnotations;
-
     /**
      * Put and replace the schema of the database
      *  Existing documents will still be kept, and stays unchanged
-     * 
+     *
      * @param schema schema of the database
-     * @param auditOptions audit options of the database 
-     * 
+     * @param auditOptions audit options of the database
+     *
      * @returns a promise of the edit records of the database
      *  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
      */
-    putSchema(
-        schema: ImbricateDatabaseSchema,
-        auditOptions?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<DatabaseEditRecord[]>;
-
+    putSchema(schema: ImbricateDatabaseSchema, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
     /**
      * Create a new document in the database
      *  If origin supports Document Edit Record, the edit record will be added by default
-     * 
+     *
      * @param properties properties of the document
      * @param auditOptions audit options of the document
-     * 
+     *
      * @returns a promise of the created document
      */
-    createDocument(
-        properties: DocumentProperties,
-        auditOptions?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<IImbricateDocument>;
-
+    createDocument(properties: DocumentProperties, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<IImbricateDocument>;
     /**
      * Get one document from the database
-     * 
+     *
      * @param uniqueIdentifier unique identifier of the document
-     * 
+     *
      * @returns a promise of the documents in the database, null if not found
      */
-    getDocument(
-        uniqueIdentifier: string,
-    ): PromiseLike<IImbricateDocument | null>;
-
+    getDocument(uniqueIdentifier: string): PromiseLike<IImbricateDocument | null>;
     /**
      * Query documents from the database
-     * 
+     *
      * @param query query of the documents
-     * 
+     *
      * @returns a promise of the documents in the database
      */
-    queryDocuments(
-        query: ImbricateDocumentQuery,
-    ): PromiseLike<IImbricateDocument[]>;
-
+    queryDocuments(query: ImbricateDocumentQuery): PromiseLike<IImbricateDocument[]>;
     /**
      * Count documents in the database
-     * 
+     *
      * @param query query of the documents
-     * 
+     *
      * @returns a promise of the count of the documents in the database
      */
-    countDocuments(
-        query: ImbricateDocumentQuery,
-    ): PromiseLike<number>;
-
+    countDocuments(query: ImbricateDocumentQuery): PromiseLike<number>;
     /**
      * Remove a document from the database
-     * 
+     *
      * @param uniqueIdentifier unique identifier of the document
      * @param auditOptions audit options of the document
      */
-    removeDocument(
-        uniqueIdentifier: string,
-        auditOptions?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<void>;
-
+    removeDocument(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<void>;
     /**
      * put annotation to the database
-     * 
+     *
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param value value of the annotation
      * @param auditOptions audit options of the database
-     * 
+     *
      * @returns a promise of the edit records of the database
      *  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: DatabaseAnnotationValue,
-        auditOptions?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<DatabaseEditRecord[]>;
-
+    putAnnotation(namespace: string, identifier: string, value: DatabaseAnnotationValue, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
     /**
      * Delete annotation from the database
-     * 
+     *
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param auditOptions audit options of the database
-     * 
+     *
      * @returns a promise of the edit records of the database
      *  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?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<DatabaseEditRecord[]>;
-
+    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
     /**
      * Add edit records to the database, 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 database edit records
      */
-    addEditRecords?(
-        records: DatabaseEditRecord[],
-    ): PromiseLike<void>;
-
+    addEditRecords?(records: DatabaseEditRecord[]): PromiseLike<void>;
     /**
      * Get edit records of the database, 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 database
      */
     getEditRecords?(): PromiseLike<DatabaseEditRecord[]>;

package/database/interface.js

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

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

@@ -3,54 +3,39 @@
  * @namespace Database
  * @description Manager
  */
-
 import { ImbricateDatabaseAuditOptions } from "./definition";
 import { IImbricateDatabase } from "./interface";
 import { ImbricateDatabaseSchemaForCreation } from "./schema";
-
 export interface IImbricateDatabaseManager {
-
     /**
      * List all databases in the origin
-     * 
+     *
      * @returns a promise of the databases in the origin
      */
     listDatabases(): PromiseLike<IImbricateDatabase[]>;
-
     /**
      * Get one database from the origin
-     * 
+     *
      * @param uniqueIdentifier unique identifier of the database
-     * 
+     *
      * @returns a promise of the database, null if not found
      */
-    getDatabase(
-        uniqueIdentifier: string,
-    ): PromiseLike<IImbricateDatabase | null>;
-
+    getDatabase(uniqueIdentifier: string): PromiseLike<IImbricateDatabase | null>;
     /**
      * Create a new database
-     * 
+     *
      * @param databaseName name of the database
      * @param schema schema of the database
      * @param auditOptions audit options of the database
-     * 
+     *
      * @returns a promise of the created database
      */
-    createDatabase(
-        databaseName: string,
-        schema: ImbricateDatabaseSchemaForCreation,
-        auditOptions?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<IImbricateDatabase>;
-
+    createDatabase(databaseName: string, schema: ImbricateDatabaseSchemaForCreation, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<IImbricateDatabase>;
     /**
      * Remove a database from the origin
-     * 
+     *
      * @param uniqueIdentifier unique identifier of the database
      * @param auditOptions audit options of deletion
      */
-    removeDatabase(
-        uniqueIdentifier: string,
-        auditOptions?: ImbricateDatabaseAuditOptions,
-    ): PromiseLike<void>;
+    removeDatabase(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<void>;
 }

package/database/manager.js

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

package/database/schema.d.ts

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

package/database/schema.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Schema
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateImbricateSchema = exports.validateImbricateSchemaProperty = void 0;
+const property_1 = require("../document/property");
+/**
+ * Validate a schema property
+ *
+ * @param property property to validate
+ *
+ * @returns a string error message if validation failed
+ *      null if validation passed
+ */
+const validateImbricateSchemaProperty = (property) => {
+    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(property_1.IMBRICATE_PROPERTY_TYPE).includes(property.propertyType)) {
+        return "Property type must be a valid type";
+    }
+    switch (property.propertyType) {
+        case property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: {
+            if (typeof property.propertyOptions !== "object") {
+                return "Property options must be an object";
+            }
+            if (typeof property.propertyOptions.allowMultiple !== "boolean") {
+                return "Property options allowMultiple must be a boolean";
+            }
+            if (!Array.isArray(property.propertyOptions.databases)) {
+                return "Property options databases must be an array";
+            }
+            for (const database of property.propertyOptions.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;
+};
+exports.validateImbricateSchemaProperty = validateImbricateSchemaProperty;
+/**
+ * Validate a schema
+ *
+ * @param schema database schema to validate
+ *
+ * @returns a string error message if validation failed
+ *    null if validation passed
+ */
+const validateImbricateSchema = (schema) => {
+    if (!Array.isArray(schema.properties)) {
+        return "Properties must be an array";
+    }
+    const propertyNames = new Set();
+    for (const property of schema.properties) {
+        const propertyValidationResult = (0, exports.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;
+};
+exports.validateImbricateSchema = validateImbricateSchema;

package/database/validate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 declare const validateImbricateDocumentQuery: (query: ImbricateDocumentQuery) => string | null;