@imbricate/core 3.11.0 → 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/feature.d.ts

@@ -6,16 +6,11 @@
 export declare enum IMBRICATE_DATABASE_FEATURE {
     DATABASE_PUT_SCHEMA = "DATABASE_PUT_SCHEMA",
     DATABASE_CREATE_DOCUMENT = "DATABASE_CREATE_DOCUMENT",
-    DATABASE_UPDATE_DOCUMENT = "DATABASE_UPDATE_DOCUMENT",
     DATABASE_DELETE_DOCUMENT = "DATABASE_DELETE_DOCUMENT",
+    DATABASE_GET_DOCUMENT = "DATABASE_GET_DOCUMENT",
     DATABASE_PUT_ANNOTATION = "DATABASE_PUT_ANNOTATION",
-    DATABASE_REMOVE_ANNOTATION = "DATABASE_REMOVE_ANNOTATION",
-    DATABASE_QUERY_DOCUMENT = "DATABASE_QUERY_DOCUMENT",
+    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 fullSupportedDatabaseFeatures: IMBRICATE_DATABASE_FEATURE[];
-export declare const editRecordExcludedDatabaseFeatures: IMBRICATE_DATABASE_FEATURE[];
-export declare const annotationExcludedDatabaseFeatures: IMBRICATE_DATABASE_FEATURE[];
-export declare const IMBRICATE_DATABASE_PRESET_FEATURES: Record<string, IMBRICATE_DATABASE_FEATURE[]>;
 export declare const checkImbricateDatabaseFeatureSupported: (features: IMBRICATE_DATABASE_FEATURE[], feature: IMBRICATE_DATABASE_FEATURE) => boolean;

package/database/feature.js

@@ -5,53 +5,18 @@
  * @description Feature
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkImbricateDatabaseFeatureSupported = exports.IMBRICATE_DATABASE_PRESET_FEATURES = exports.annotationExcludedDatabaseFeatures = exports.editRecordExcludedDatabaseFeatures = exports.fullSupportedDatabaseFeatures = exports.IMBRICATE_DATABASE_FEATURE = void 0;
+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_UPDATE_DOCUMENT"] = "DATABASE_UPDATE_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_REMOVE_ANNOTATION"] = "DATABASE_REMOVE_ANNOTATION";
-    IMBRICATE_DATABASE_FEATURE["DATABASE_QUERY_DOCUMENT"] = "DATABASE_QUERY_DOCUMENT";
+    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 = {}));
-exports.fullSupportedDatabaseFeatures = [
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_UPDATE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_REMOVE_ANNOTATION,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_QUERY_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD,
-];
-exports.editRecordExcludedDatabaseFeatures = [
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_UPDATE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_ANNOTATION,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_REMOVE_ANNOTATION,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_QUERY_DOCUMENT,
-];
-exports.annotationExcludedDatabaseFeatures = [
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_SCHEMA,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_CREATE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_UPDATE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_DELETE_DOCUMENT,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_PUT_EDIT_RECORD,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_GET_EDIT_RECORD,
-    IMBRICATE_DATABASE_FEATURE.DATABASE_QUERY_DOCUMENT,
-];
-exports.IMBRICATE_DATABASE_PRESET_FEATURES = {
-    FULL_SUPPORTED_FEATURES: exports.fullSupportedDatabaseFeatures,
-    EDIT_RECORD_EXCLUDED_FEATURES: exports.editRecordExcludedDatabaseFeatures,
-    ANNOTATION_EXCLUDED_FEATURES: exports.annotationExcludedDatabaseFeatures,
-};
 const checkImbricateDatabaseFeatureSupported = (features, feature) => {
     return features.includes(feature);
 };

package/database/interface.d.ts

@@ -3,10 +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 {
     /**
@@ -18,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
      */
@@ -42,11 +42,10 @@ export interface IImbricateDatabase {
      * @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
@@ -56,9 +55,10 @@ export interface IImbricateDatabase {
      * @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
      *
@@ -66,9 +66,10 @@ export interface IImbricateDatabase {
      *
      * @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
      *
@@ -76,9 +77,10 @@ export interface IImbricateDatabase {
      *
      * @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
      *
@@ -86,9 +88,10 @@ export interface IImbricateDatabase {
      *
      * @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
      *
@@ -96,10 +99,13 @@ export interface IImbricateDatabase {
      *
      * @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, optional
+     * Put annotation to the database
      *
      * RequireFeature: DATABASE_PUT_ANNOTATION
      *
@@ -108,27 +114,26 @@ export interface IImbricateDatabase {
      * @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, optional
+     * Delete annotation from the database
      *
-     * RequireFeature: DATABASE_REMOVE_ANNOTATION
+     * 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
@@ -136,17 +141,21 @@ export interface IImbricateDatabase {
      * 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
      *
      * RequireFeature: DATABASE_GET_EDIT_RECORD
      *
-     * @returns a promise of the edit records of the database
+     * @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>;
 }

package/database/outcome.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Outcome
+ */
+import { IImbricateDocument } from "../document/interface";
+import { DatabaseEditRecord } from "./definition";
+export declare const S_Database_PutSchema_VersionConflict: unique symbol;
+export type ImbricateDatabasePutSchemaOutcomeSymbol = typeof S_Database_PutSchema_VersionConflict;
+export type ImbricateDatabasePutSchemaOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabasePutSchemaOutcomeSymbol;
+export declare const S_Database_CreateDocument_IdentifierDuplicated: unique symbol;
+export type ImbricateDatabaseCreateDocumentOutcomeSymbol = typeof S_Database_CreateDocument_IdentifierDuplicated;
+export type ImbricateDatabaseCreateDocumentOutcome = {
+    readonly document: IImbricateDocument;
+} | ImbricateDatabaseCreateDocumentOutcomeSymbol;
+export declare const S_Database_GetDocument_NotFound: unique symbol;
+export type ImbricateDatabaseGetDocumentOutcomeSymbol = typeof S_Database_GetDocument_NotFound;
+export type ImbricateDatabaseGetDocumentOutcome = {
+    readonly document: IImbricateDocument;
+} | ImbricateDatabaseGetDocumentOutcomeSymbol;
+export declare const S_Database_QueryDocuments_Stale: unique symbol;
+export type ImbricateDatabaseQueryDocumentsOutcomeSymbol = typeof S_Database_QueryDocuments_Stale;
+export type ImbricateDatabaseQueryDocumentsOutcome = {
+    readonly documents: IImbricateDocument[];
+} | ImbricateDatabaseQueryDocumentsOutcomeSymbol;
+export declare const S_Database_CountDocuments_Stale: unique symbol;
+export type ImbricateDatabaseCountDocumentsOutcomeSymbol = typeof S_Database_CountDocuments_Stale;
+export type ImbricateDatabaseCountDocumentsOutcome = {
+    readonly count: number;
+} | ImbricateDatabaseCountDocumentsOutcomeSymbol;
+export declare const S_Database_RemoveDocument_NotFound: unique symbol;
+export type ImbricateDatabaseRemoveDocumentOutcomeSymbol = typeof S_Database_RemoveDocument_NotFound;
+export type ImbricateDatabaseRemoveDocumentOutcome = {
+    readonly success: boolean;
+} | ImbricateDatabaseRemoveDocumentOutcomeSymbol;
+export declare const S_Database_PutAnnotation_InvalidNamespace: unique symbol;
+export declare const S_Database_PutAnnotation_InvalidIdentifier: unique symbol;
+export type ImbricateDatabasePutAnnotationOutcomeSymbol = typeof S_Database_PutAnnotation_InvalidNamespace | typeof S_Database_PutAnnotation_InvalidIdentifier;
+export type ImbricateDatabasePutAnnotationOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabasePutAnnotationOutcomeSymbol;
+export declare const S_Database_DeleteAnnotation_NotFound: unique symbol;
+export type ImbricateDatabaseDeleteAnnotationOutcomeSymbol = typeof S_Database_DeleteAnnotation_NotFound;
+export type ImbricateDatabaseDeleteAnnotationOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabaseDeleteAnnotationOutcomeSymbol;
+export declare const S_Database_AddEditRecords_InvalidEditRecord: unique symbol;
+export type ImbricateDatabaseAddEditRecordsOutcomeSymbol = typeof S_Database_AddEditRecords_InvalidEditRecord;
+export type ImbricateDatabaseAddEditRecordsOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabaseAddEditRecordsOutcomeSymbol;
+export declare const S_Database_GetEditRecords_NotFound: unique symbol;
+export type ImbricateDatabaseGetEditRecordsOutcomeSymbol = typeof S_Database_GetEditRecords_NotFound;
+export type ImbricateDatabaseGetEditRecordsOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabaseGetEditRecordsOutcomeSymbol;