@imbricate/core 3.10.1 → 3.12.0

package/database/base-class/essential-readonly.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Essential Readonly
+ */
+import { DocumentProperties } from "../../document/property";
+import { ImbricateDatabaseAuditOptions } from "../definition";
+import { IMBRICATE_DATABASE_FEATURE } from "../feature";
+import { IImbricateDatabase } from "../interface";
+import { ImbricateDatabaseCreateDocumentOutcome, ImbricateDatabasePutSchemaOutcome, ImbricateDatabaseRemoveDocumentOutcome } from "../outcome";
+import { ImbricateDatabaseSchema } from "../schema";
+import { ImbricateDatabaseEssentialBase } from "./essential";
+export declare abstract class ImbricateDatabaseEssentialReadOnlyBase extends ImbricateDatabaseEssentialBase implements IImbricateDatabase {
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
+    putSchema(_schema: ImbricateDatabaseSchema, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutSchemaOutcome>;
+    createDocument(_properties: DocumentProperties, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseCreateDocumentOutcome>;
+    removeDocument(_uniqueIdentifier: string, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseRemoveDocumentOutcome>;
+}

package/database/base-class/essential-readonly.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Essential Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseEssentialReadOnlyBase = void 0;
+const feature_not_supported_1 = require("../../error/database/feature-not-supported");
+const feature_1 = require("../feature");
+const essential_1 = require("./essential");
+class ImbricateDatabaseEssentialReadOnlyBase extends essential_1.ImbricateDatabaseEssentialBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_DOCUMENT,
+        ];
+    }
+    putSchema(_schema, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA);
+    }
+    createDocument(_properties, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT);
+    }
+    removeDocument(_uniqueIdentifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT);
+    }
+}
+exports.ImbricateDatabaseEssentialReadOnlyBase = ImbricateDatabaseEssentialReadOnlyBase;

package/database/base-class/essential.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Essential
+ */
+import { DatabaseAnnotationValue, DatabaseAnnotations, DatabaseEditRecord, ImbricateDatabaseAuditOptions } from "../definition";
+import { IMBRICATE_DATABASE_FEATURE } from "../feature";
+import { IImbricateDatabase } from "../interface";
+import { ImbricateDatabaseAddEditRecordsOutcome, ImbricateDatabaseDeleteAnnotationOutcome, ImbricateDatabaseGetEditRecordsOutcome, ImbricateDatabasePutAnnotationOutcome } from "../outcome";
+import { ImbricateDatabaseFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDatabaseEssentialBase extends ImbricateDatabaseFullFeatureBase implements IImbricateDatabase {
+    readonly annotations: DatabaseAnnotations;
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
+    putAnnotation(_namespace: string, _identifier: string, _value: DatabaseAnnotationValue, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseDeleteAnnotationOutcome>;
+    addEditRecords(_records: DatabaseEditRecord[]): PromiseLike<ImbricateDatabaseAddEditRecordsOutcome>;
+    getEditRecords(): PromiseLike<ImbricateDatabaseGetEditRecordsOutcome>;
+}

package/database/base-class/essential.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Essential
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseEssentialBase = void 0;
+const feature_not_supported_1 = require("../../error/database/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDatabaseEssentialBase extends full_feature_1.ImbricateDatabaseFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_DOCUMENT,
+        ];
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_ANNOTATION);
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD);
+    }
+    getEditRecords() {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD);
+    }
+}
+exports.ImbricateDatabaseEssentialBase = ImbricateDatabaseEssentialBase;

package/database/base-class/exclude-annotation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Exclude Annotation
+ */
+import { DatabaseAnnotationValue, DatabaseAnnotations, ImbricateDatabaseAuditOptions } from "../definition";
+import { IMBRICATE_DATABASE_FEATURE } from "../feature";
+import { IImbricateDatabase } from "../interface";
+import { ImbricateDatabaseDeleteAnnotationOutcome, ImbricateDatabasePutAnnotationOutcome } from "../outcome";
+import { ImbricateDatabaseFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDatabaseExcludeAnnotationBase extends ImbricateDatabaseFullFeatureBase implements IImbricateDatabase {
+    readonly annotations: DatabaseAnnotations;
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
+    putAnnotation(_namespace: string, _identifier: string, _value: DatabaseAnnotationValue, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseDeleteAnnotationOutcome>;
+}

package/database/base-class/exclude-annotation.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Exclude Annotation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseExcludeAnnotationBase = void 0;
+const feature_not_supported_1 = require("../../error/database/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDatabaseExcludeAnnotationBase extends full_feature_1.ImbricateDatabaseFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD,
+        ];
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_ANNOTATION);
+    }
+}
+exports.ImbricateDatabaseExcludeAnnotationBase = ImbricateDatabaseExcludeAnnotationBase;

package/database/base-class/exclude-edit-records.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Exclude Edit Records
+ */
+import { DatabaseEditRecord } from "../definition";
+import { IMBRICATE_DATABASE_FEATURE } from "../feature";
+import { IImbricateDatabase } from "../interface";
+import { ImbricateDatabaseAddEditRecordsOutcome, ImbricateDatabaseGetEditRecordsOutcome } from "../outcome";
+import { ImbricateDatabaseFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDatabaseExcludeEditRecordsBase extends ImbricateDatabaseFullFeatureBase implements IImbricateDatabase {
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
+    addEditRecords(_records: DatabaseEditRecord[]): PromiseLike<ImbricateDatabaseAddEditRecordsOutcome>;
+    getEditRecords(): PromiseLike<ImbricateDatabaseGetEditRecordsOutcome>;
+}

package/database/base-class/exclude-edit-records.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Exclude Edit Records
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseExcludeEditRecordsBase = void 0;
+const feature_not_supported_1 = require("../../error/database/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDatabaseExcludeEditRecordsBase extends full_feature_1.ImbricateDatabaseFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_ANNOTATION,
+        ];
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD);
+    }
+    getEditRecords() {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD);
+    }
+}
+exports.ImbricateDatabaseExcludeEditRecordsBase = ImbricateDatabaseExcludeEditRecordsBase;

package/database/base-class/full-feature-readonly.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @author WMXPY
+ * @namespace Database_BaseClass
+ * @description Full Feature Readonly
+ */
+import { DocumentProperties } from "../../document/property";
+import { DatabaseAnnotationValue, DatabaseEditRecord, ImbricateDatabaseAuditOptions } from "../definition";
+import { IMBRICATE_DATABASE_FEATURE } from "../feature";
+import { IImbricateDatabase } from "../interface";
+import { ImbricateDatabaseAddEditRecordsOutcome, ImbricateDatabaseCreateDocumentOutcome, ImbricateDatabaseDeleteAnnotationOutcome, ImbricateDatabasePutAnnotationOutcome, ImbricateDatabasePutSchemaOutcome, ImbricateDatabaseRemoveDocumentOutcome } from "../outcome";
+import { ImbricateDatabaseSchema } from "../schema";
+import { ImbricateDatabaseFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDatabaseFullFeatureReadOnlyBase extends ImbricateDatabaseFullFeatureBase implements IImbricateDatabase {
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
+    putSchema(_schema: ImbricateDatabaseSchema, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutSchemaOutcome>;
+    createDocument(_properties: DocumentProperties, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseCreateDocumentOutcome>;
+    removeDocument(_uniqueIdentifier: string, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseRemoveDocumentOutcome>;
+    putAnnotation(_namespace: string, _identifier: string, _value: DatabaseAnnotationValue, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseDeleteAnnotationOutcome>;
+    addEditRecords(_records: DatabaseEditRecord[]): PromiseLike<ImbricateDatabaseAddEditRecordsOutcome>;
+}

package/database/base-class/full-feature-readonly.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database_BaseClass
+ * @description Full Feature Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseFullFeatureReadOnlyBase = void 0;
+const feature_not_supported_1 = require("../../error/database/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDatabaseFullFeatureReadOnlyBase extends full_feature_1.ImbricateDatabaseFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD,
+        ];
+    }
+    putSchema(_schema, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA);
+    }
+    createDocument(_properties, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT);
+    }
+    removeDocument(_uniqueIdentifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT);
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_ANNOTATION);
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDatabaseFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD);
+    }
+}
+exports.ImbricateDatabaseFullFeatureReadOnlyBase = ImbricateDatabaseFullFeatureReadOnlyBase;

package/database/base-class/full-feature.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @author WMXPY
+ * @namespace Database_BaseClass
+ * @description Full Feature
+ */
+import { DocumentProperties } from "../../document/property";
+import { DatabaseAnnotationValue, DatabaseAnnotations, DatabaseEditRecord, ImbricateDatabaseAuditOptions, ImbricateDocumentQuery } from "../definition";
+import { IMBRICATE_DATABASE_FEATURE } from "../feature";
+import { IImbricateDatabase } from "../interface";
+import { ImbricateDatabaseAddEditRecordsOutcome, ImbricateDatabaseCountDocumentsOutcome, ImbricateDatabaseCreateDocumentOutcome, ImbricateDatabaseDeleteAnnotationOutcome, ImbricateDatabaseGetDocumentOutcome, ImbricateDatabaseGetEditRecordsOutcome, ImbricateDatabasePutAnnotationOutcome, ImbricateDatabasePutSchemaOutcome, ImbricateDatabaseQueryDocumentsOutcome, ImbricateDatabaseRemoveDocumentOutcome } from "../outcome";
+import { ImbricateDatabaseSchema } from "../schema";
+export declare abstract class ImbricateDatabaseFullFeatureBase implements IImbricateDatabase {
+    abstract readonly uniqueIdentifier: string;
+    abstract readonly databaseName: string;
+    abstract readonly databaseVersion: string;
+    abstract readonly schema: ImbricateDatabaseSchema;
+    abstract readonly annotations: DatabaseAnnotations;
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
+    abstract putSchema(schema: ImbricateDatabaseSchema, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutSchemaOutcome>;
+    abstract createDocument(properties: DocumentProperties, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseCreateDocumentOutcome>;
+    abstract getDocument(uniqueIdentifier: string): PromiseLike<ImbricateDatabaseGetDocumentOutcome>;
+    abstract queryDocuments(query: ImbricateDocumentQuery): PromiseLike<ImbricateDatabaseQueryDocumentsOutcome>;
+    abstract countDocuments(query: ImbricateDocumentQuery): PromiseLike<ImbricateDatabaseCountDocumentsOutcome>;
+    abstract removeDocument(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseRemoveDocumentOutcome>;
+    abstract putAnnotation(namespace: string, identifier: string, value: DatabaseAnnotationValue, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutAnnotationOutcome>;
+    abstract deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseDeleteAnnotationOutcome>;
+    abstract addEditRecords(records: DatabaseEditRecord[]): PromiseLike<ImbricateDatabaseAddEditRecordsOutcome>;
+    abstract getEditRecords(): PromiseLike<ImbricateDatabaseGetEditRecordsOutcome>;
+}

package/database/base-class/full-feature.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database_BaseClass
+ * @description Full Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseFullFeatureBase = void 0;
+const feature_1 = require("../feature");
+class ImbricateDatabaseFullFeatureBase {
+    constructor() {
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_ANNOTATION,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_DOCUMENT,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD,
+            feature_1.IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD,
+        ];
+    }
+}
+exports.ImbricateDatabaseFullFeatureBase = ImbricateDatabaseFullFeatureBase;

package/database/definition.d.ts

@@ -60,10 +60,16 @@ export type DatabaseEditOperationDeleteAnnotation = {
     readonly annotationIdentifier: string;
 };
 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;
+/**
+ * Edit operation of the database
+ */
 export type DatabaseEditOperation<T extends IMBRICATE_DATABASE_EDIT_TYPE> = {
     readonly action: T;
     readonly value: DatabaseEditOperationValue<T>;
 };
+/**
+ * Edit record of the database
+ */
 export type DatabaseEditRecord = {
     readonly uniqueIdentifier: string;
     readonly editAt: Date;
@@ -72,8 +78,17 @@ export type DatabaseEditRecord = {
     readonly operations: Array<DatabaseEditOperation<IMBRICATE_DATABASE_EDIT_TYPE>>;
     readonly author?: ImbricateAuthor;
 };
+/**
+ * Annotations of the database
+ */
 export type DatabaseAnnotations = Record<DatabaseAnnotationKey, DatabaseAnnotationValue>;
+/**
+ * Annotation key of the database
+ */
 export type DatabaseAnnotationKey = string;
+/**
+ * Annotation value of the database
+ */
 export type DatabaseAnnotationValue = {
     readonly namespace: string;
     readonly identifier: string;

package/database/feature.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Feature
+ */
+export declare enum IMBRICATE_DATABASE_FEATURE {
+    DATABASE_PUT_SCHEMA = "DATABASE_PUT_SCHEMA",
+    DATABASE_CREATE_DOCUMENT = "DATABASE_CREATE_DOCUMENT",
+    DATABASE_DELETE_DOCUMENT = "DATABASE_DELETE_DOCUMENT",
+    DATABASE_GET_DOCUMENT = "DATABASE_GET_DOCUMENT",
+    DATABASE_PUT_ANNOTATION = "DATABASE_PUT_ANNOTATION",
+    DATABASE_DELETE_ANNOTATION = "DATABASE_DELETE_ANNOTATION",
+    DATABASE_PUT_EDIT_RECORD = "DATABASE_PUT_EDIT_RECORD",
+    DATABASE_GET_EDIT_RECORD = "DATABASE_GET_EDIT_RECORD"
+}
+export declare const checkImbricateDatabaseFeatureSupported: (features: IMBRICATE_DATABASE_FEATURE[], feature: IMBRICATE_DATABASE_FEATURE) => boolean;

package/database/feature.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImbricateDatabaseFeatureSupported = exports.IMBRICATE_DATABASE_FEATURE = void 0;
+var IMBRICATE_DATABASE_FEATURE;
+(function (IMBRICATE_DATABASE_FEATURE) {
+    IMBRICATE_DATABASE_FEATURE["DATABASE_PUT_SCHEMA"] = "DATABASE_PUT_SCHEMA";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_CREATE_DOCUMENT"] = "DATABASE_CREATE_DOCUMENT";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_DELETE_DOCUMENT"] = "DATABASE_DELETE_DOCUMENT";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_GET_DOCUMENT"] = "DATABASE_GET_DOCUMENT";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_PUT_ANNOTATION"] = "DATABASE_PUT_ANNOTATION";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_DELETE_ANNOTATION"] = "DATABASE_DELETE_ANNOTATION";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_PUT_EDIT_RECORD"] = "DATABASE_PUT_EDIT_RECORD";
+    IMBRICATE_DATABASE_FEATURE["DATABASE_GET_EDIT_RECORD"] = "DATABASE_GET_EDIT_RECORD";
+})(IMBRICATE_DATABASE_FEATURE || (exports.IMBRICATE_DATABASE_FEATURE = IMBRICATE_DATABASE_FEATURE = {}));
+const checkImbricateDatabaseFeatureSupported = (features, feature) => {
+    return features.includes(feature);
+};
+exports.checkImbricateDatabaseFeatureSupported = checkImbricateDatabaseFeatureSupported;

package/database/interface.d.ts

@@ -3,9 +3,10 @@
  * @namespace Database
  * @description Interface
  */
-import { IImbricateDocument } from "../document/interface";
 import { DocumentProperties } from "../document/property";
 import { DatabaseAnnotationValue, DatabaseAnnotations, DatabaseEditRecord, ImbricateDatabaseAuditOptions, ImbricateDocumentQuery } from "./definition";
+import { IMBRICATE_DATABASE_FEATURE } from "./feature";
+import { ImbricateDatabaseAddEditRecordsOutcome, ImbricateDatabaseCountDocumentsOutcome, ImbricateDatabaseCreateDocumentOutcome, ImbricateDatabaseDeleteAnnotationOutcome, ImbricateDatabaseGetDocumentOutcome, ImbricateDatabaseGetEditRecordsOutcome, ImbricateDatabasePutAnnotationOutcome, ImbricateDatabasePutSchemaOutcome, ImbricateDatabaseQueryDocumentsOutcome, ImbricateDatabaseRemoveDocumentOutcome } from "./outcome";
 import { ImbricateDatabaseSchema } from "./schema";
 export interface IImbricateDatabase {
     /**
@@ -17,9 +18,9 @@ export interface IImbricateDatabase {
      */
     readonly databaseName: string;
     /**
-     * Version of the database draft
+     * Version of the database
      */
-    readonly databaseVersion: number;
+    readonly databaseVersion: string;
     /**
      * Schema of the database
      */
@@ -28,100 +29,133 @@ export interface IImbricateDatabase {
      * Annotations of the database
      */
     readonly annotations: DatabaseAnnotations;
+    /**
+     * Supported features of the database
+     */
+    readonly supportedFeatures: IMBRICATE_DATABASE_FEATURE[];
     /**
      * Put and replace the schema of the database
      *  Existing documents will still be kept, and stays unchanged
      *
+     * RequireFeature: DATABASE_PUT_SCHEMA
+     *
      * @param schema schema 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
+     * @returns a promise of the outcome of the put schema
+     *  Symbol: S_PutSchema_VersionConflict - if the version conflict
      */
-    putSchema(schema: ImbricateDatabaseSchema, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
+    putSchema(schema: ImbricateDatabaseSchema, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutSchemaOutcome>;
     /**
      * Create a new document in the database
      *  If origin supports Document Edit Record, the edit record will be added by default
      *
+     * RequireFeature: DATABASE_CREATE_DOCUMENT
+     *
      * @param properties properties of the document
      * @param auditOptions audit options of the document
      *
-     * @returns a promise of the created document
+     * @returns a promise of the outcome of the create document
+     *  Symbol: S_CreateDocument_IdentifierDuplicated - if the identifier is duplicated
      */
-    createDocument(properties: DocumentProperties, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<IImbricateDocument>;
+    createDocument(properties: DocumentProperties, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseCreateDocumentOutcome>;
     /**
      * Get one document from the database
      *
+     * RequireFeature: DATABASE_GET_DOCUMENT
+     *
      * @param uniqueIdentifier unique identifier of the document
      *
-     * @returns a promise of the documents in the database, null if not found
+     * @returns a promise of the outcome of the get document
+     *  Symbol: S_GetDocument_NotFound - if the document is not found
      */
-    getDocument(uniqueIdentifier: string): PromiseLike<IImbricateDocument | null>;
+    getDocument(uniqueIdentifier: string): PromiseLike<ImbricateDatabaseGetDocumentOutcome>;
     /**
      * Query documents from the database
      *
+     * RequireFeature: DATABASE_QUERY_DOCUMENT
+     *
      * @param query query of the documents
      *
-     * @returns a promise of the documents in the database
+     * @returns a promise of the outcome of the query documents
+     *  Symbol: S_QueryDocuments_Stale - if the documents are stale
      */
-    queryDocuments(query: ImbricateDocumentQuery): PromiseLike<IImbricateDocument[]>;
+    queryDocuments(query: ImbricateDocumentQuery): PromiseLike<ImbricateDatabaseQueryDocumentsOutcome>;
     /**
      * Count documents in the database
      *
+     * RequireFeature: DATABASE_COUNT_DOCUMENT
+     *
      * @param query query of the documents
      *
-     * @returns a promise of the count of the documents in the database
+     * @returns a promise of the outcome of the count documents
+     *  Symbol: S_CountDocuments_Stale - if the documents are stale
      */
-    countDocuments(query: ImbricateDocumentQuery): PromiseLike<number>;
+    countDocuments(query: ImbricateDocumentQuery): PromiseLike<ImbricateDatabaseCountDocumentsOutcome>;
     /**
      * Remove a document from the database
      *
+     * RequireFeature: DATABASE_DELETE_DOCUMENT
+     *
      * @param uniqueIdentifier unique identifier of the document
      * @param auditOptions audit options of the document
+     *
+     * @returns a promise of the outcome of the remove document
+     *  Symbol: S_RemoveDocument_NotFound - if the document is not found
      */
-    removeDocument(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<void>;
+    removeDocument(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseRemoveDocumentOutcome>;
     /**
-     * put annotation to the database
+     * Put annotation to the database
+     *
+     * RequireFeature: DATABASE_PUT_ANNOTATION
      *
      * @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
+     * @returns a promise of the outcome of the put annotation
+     *  Symbol: S_PutAnnotation_InvalidNamespace - if the namespace is invalid
+     *  Symbol: S_PutAnnotation_InvalidIdentifier - if the identifier is invalid
      */
-    putAnnotation(namespace: string, identifier: string, value: DatabaseAnnotationValue, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
+    putAnnotation(namespace: string, identifier: string, value: DatabaseAnnotationValue, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabasePutAnnotationOutcome>;
     /**
      * Delete annotation from the database
      *
+     * RequireFeature: DATABASE_DELETE_ANNOTATION
+     *
      * @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
+     * @returns a promise of the outcome of the delete annotation
+     *  Symbol: S_DeleteAnnotation_NotFound - if the annotation is not found
      */
-    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
+    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseDeleteAnnotationOutcome>;
     /**
-     * Add edit records to the database, optional
+     * Add edit records to the database
      *  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
      *
+     * RequireFeature: DATABASE_PUT_EDIT_RECORD
+     *
      * @param records database edit records
+     *
+     * @returns a promise of the outcome of the add edit records
+     *  Symbol: S_AddEditRecords_InvalidEditRecord - if the edit record is invalid
      */
-    addEditRecords?(records: DatabaseEditRecord[]): PromiseLike<void>;
+    addEditRecords(records: DatabaseEditRecord[]): PromiseLike<ImbricateDatabaseAddEditRecordsOutcome>;
     /**
-     * Get edit records of the database, optional
+     * Get edit records of the database
      *  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
+     * RequireFeature: DATABASE_GET_EDIT_RECORD
+     *
+     * @returns a promise of the outcome of the get edit records
+     *  Symbol: S_GetEditRecords_NotFound - if the edit records are not found
      */
-    getEditRecords?(): PromiseLike<DatabaseEditRecord[]>;
+    getEditRecords(): PromiseLike<ImbricateDatabaseGetEditRecordsOutcome>;
 }