@imbricate/core 3.11.0 → 3.14.0

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;

package/database/outcome.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Outcome
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S_Database_GetEditRecords_NotFound = exports.S_Database_AddEditRecords_InvalidEditRecord = exports.S_Database_DeleteAnnotation_NotFound = exports.S_Database_PutAnnotation_InvalidIdentifier = exports.S_Database_PutAnnotation_InvalidNamespace = exports.S_Database_RemoveDocument_NotFound = exports.S_Database_CountDocuments_Stale = exports.S_Database_QueryDocuments_Stale = exports.S_Database_GetDocument_NotFound = exports.S_Database_CreateDocument_IdentifierDuplicated = exports.S_Database_PutSchema_VersionConflict = void 0;
+// Put Schema
+exports.S_Database_PutSchema_VersionConflict = Symbol("Database_PutSchema_VersionConflict");
+// Create Document
+exports.S_Database_CreateDocument_IdentifierDuplicated = Symbol("Database_CreateDocument_IdentifierDuplicated");
+// Get Document
+exports.S_Database_GetDocument_NotFound = Symbol("Database_GetDocument_NotFound");
+// Query Documents
+exports.S_Database_QueryDocuments_Stale = Symbol("Database_QueryDocuments_Stale");
+exports.S_Database_CountDocuments_Stale = Symbol("Database_CountDocuments_Stale");
+// Remove Document
+exports.S_Database_RemoveDocument_NotFound = Symbol("Database_RemoveDocument_NotFound");
+// Put Annotation
+exports.S_Database_PutAnnotation_InvalidNamespace = Symbol("Database_PutAnnotation_InvalidNamespace");
+exports.S_Database_PutAnnotation_InvalidIdentifier = Symbol("Database_PutAnnotation_InvalidIdentifier");
+// Delete Annotation
+exports.S_Database_DeleteAnnotation_NotFound = Symbol("Database_DeleteAnnotation_NotFound");
+// Add Edit Records
+exports.S_Database_AddEditRecords_InvalidEditRecord = Symbol("Database_AddEditRecords_InvalidEditRecord");
+// Get Edit Records
+exports.S_Database_GetEditRecords_NotFound = Symbol("Database_GetEditRecords_NotFound");

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

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Full Feature
+ */
+import { ImbricateDatabaseAuditOptions } from "../../database/definition";
+import { ImbricateDatabaseSchemaForCreation } from "../../database/schema";
+import { IImbricateDatabaseManager } from "../database-manager";
+import { IMBRICATE_DATABASE_MANAGER_FEATURE } from "../feature";
+import { ImbricateDatabaseManagerCreateDatabaseOutcome, ImbricateDatabaseManagerGetDatabaseOutcome, ImbricateDatabaseManagerListDatabasesOutcome, ImbricateDatabaseManagerRemoveDatabaseOutcome } from "../outcome";
+export declare abstract class ImbricateDatabaseManagerFullFeatureBase implements IImbricateDatabaseManager {
+    readonly supportedFeatures: IMBRICATE_DATABASE_MANAGER_FEATURE[];
+    abstract listDatabases(): PromiseLike<ImbricateDatabaseManagerListDatabasesOutcome>;
+    abstract getDatabase(uniqueIdentifier: string): PromiseLike<ImbricateDatabaseManagerGetDatabaseOutcome>;
+    abstract createDatabase(databaseName: string, schema: ImbricateDatabaseSchemaForCreation, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseManagerCreateDatabaseOutcome>;
+    abstract removeDatabase(uniqueIdentifier: string): PromiseLike<ImbricateDatabaseManagerRemoveDatabaseOutcome>;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Full Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseManagerFullFeatureBase = void 0;
+const feature_1 = require("../feature");
+class ImbricateDatabaseManagerFullFeatureBase {
+    constructor() {
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_MANAGER_FEATURE.DATABASE_MANAGER_GET_DATABASE,
+            feature_1.IMBRICATE_DATABASE_MANAGER_FEATURE.DATABASE_MANAGER_PUT_DATABASE,
+            feature_1.IMBRICATE_DATABASE_MANAGER_FEATURE.DATABASE_MANAGER_DELETE_DATABASE,
+        ];
+    }
+}
+exports.ImbricateDatabaseManagerFullFeatureBase = ImbricateDatabaseManagerFullFeatureBase;

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

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Readonly
+ */
+import { ImbricateDatabaseAuditOptions } from "../../database/definition";
+import { ImbricateDatabaseSchemaForCreation } from "../../database/schema";
+import { IImbricateDatabaseManager } from "../database-manager";
+import { IMBRICATE_DATABASE_MANAGER_FEATURE } from "../feature";
+import { ImbricateDatabaseManagerCreateDatabaseOutcome, ImbricateDatabaseManagerRemoveDatabaseOutcome } from "../outcome";
+import { ImbricateDatabaseManagerFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDatabaseManagerReadonlyBase extends ImbricateDatabaseManagerFullFeatureBase implements IImbricateDatabaseManager {
+    readonly supportedFeatures: IMBRICATE_DATABASE_MANAGER_FEATURE[];
+    createDatabase(_databaseName: string, _schema: ImbricateDatabaseSchemaForCreation, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseManagerCreateDatabaseOutcome>;
+    removeDatabase(_uniqueIdentifier: string, _auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseManagerRemoveDatabaseOutcome>;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDatabaseManagerReadonlyBase = void 0;
+const feature_not_supported_1 = require("../../error/database-manager/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDatabaseManagerReadonlyBase extends full_feature_1.ImbricateDatabaseManagerFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DATABASE_MANAGER_FEATURE.DATABASE_MANAGER_GET_DATABASE,
+        ];
+    }
+    createDatabase(_databaseName, _schema, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseManagerFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_MANAGER_FEATURE.DATABASE_MANAGER_PUT_DATABASE);
+    }
+    removeDatabase(_uniqueIdentifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDatabaseManagerFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DATABASE_MANAGER_FEATURE.DATABASE_MANAGER_DELETE_DATABASE);
+    }
+}
+exports.ImbricateDatabaseManagerReadonlyBase = ImbricateDatabaseManagerReadonlyBase;

package/database-manager/database-manager.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Database Manager
+ */
+import { ImbricateDatabaseAuditOptions } from "../database/definition";
+import { ImbricateDatabaseSchemaForCreation } from "../database/schema";
+import { IMBRICATE_DATABASE_MANAGER_FEATURE } from "./feature";
+import { ImbricateDatabaseManagerCreateDatabaseOutcome, ImbricateDatabaseManagerGetDatabaseOutcome, ImbricateDatabaseManagerListDatabasesOutcome, ImbricateDatabaseManagerRemoveDatabaseOutcome } from "./outcome";
+export interface IImbricateDatabaseManager {
+    /**
+     * Supported features of the database manager
+     */
+    readonly supportedFeatures: IMBRICATE_DATABASE_MANAGER_FEATURE[];
+    /**
+     * List all databases in the origin
+     *
+     * @returns a promise of the databases in the origin
+     *  Symbol: S_DatabaseManager_ListDatabases_Stale - if the databases are stale
+     */
+    listDatabases(): PromiseLike<ImbricateDatabaseManagerListDatabasesOutcome>;
+    /**
+     * Get one database from the origin
+     *
+     * @param uniqueIdentifier unique identifier of the database
+     *
+     * @returns a promise of the database
+     *  Symbol: S_DatabaseManager_GetDatabase_NotFound - if the database is not found
+     */
+    getDatabase(uniqueIdentifier: string): PromiseLike<ImbricateDatabaseManagerGetDatabaseOutcome>;
+    /**
+     * 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
+     *  Symbol: S_DatabaseManager_CreateDatabase_IdentifierDuplicated - if the identifier is duplicated
+     */
+    createDatabase(databaseName: string, schema: ImbricateDatabaseSchemaForCreation, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseManagerCreateDatabaseOutcome>;
+    /**
+     * Remove a database from the origin
+     *
+     * @param uniqueIdentifier unique identifier of the database
+     * @param auditOptions audit options of deletion
+     *
+     * @returns a promise of the outcome of the removal
+     *  Symbol: S_DatabaseManager_RemoveDatabase_NotFound - if the database is not found
+     */
+    removeDatabase(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<ImbricateDatabaseManagerRemoveDatabaseOutcome>;
+}

package/{static/manager.js → database-manager/database-manager.js}

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

package/database-manager/export.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Export
+ */
+export * from "./base-class/full-feature";
+export * from "./base-class/readonly";
+export * from "./database-manager";
+export * from "./feature";
+export * from "./outcome";

package/database-manager/export.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Export
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-class/full-feature"), exports);
+__exportStar(require("./base-class/readonly"), exports);
+__exportStar(require("./database-manager"), exports);
+__exportStar(require("./feature"), exports);
+__exportStar(require("./outcome"), exports);

package/database-manager/feature.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Feature
+ */
+export declare enum IMBRICATE_DATABASE_MANAGER_FEATURE {
+    DATABASE_MANAGER_GET_DATABASE = "DATABASE_MANAGER_GET_DATABASE",
+    DATABASE_MANAGER_PUT_DATABASE = "DATABASE_MANAGER_PUT_DATABASE",
+    DATABASE_MANAGER_DELETE_DATABASE = "DATABASE_MANAGER_DELETE_DATABASE"
+}
+export declare const checkImbricateDatabaseManagerFeatureSupported: (features: IMBRICATE_DATABASE_MANAGER_FEATURE[], feature: IMBRICATE_DATABASE_MANAGER_FEATURE) => boolean;

package/database-manager/feature.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImbricateDatabaseManagerFeatureSupported = exports.IMBRICATE_DATABASE_MANAGER_FEATURE = void 0;
+var IMBRICATE_DATABASE_MANAGER_FEATURE;
+(function (IMBRICATE_DATABASE_MANAGER_FEATURE) {
+    IMBRICATE_DATABASE_MANAGER_FEATURE["DATABASE_MANAGER_GET_DATABASE"] = "DATABASE_MANAGER_GET_DATABASE";
+    IMBRICATE_DATABASE_MANAGER_FEATURE["DATABASE_MANAGER_PUT_DATABASE"] = "DATABASE_MANAGER_PUT_DATABASE";
+    IMBRICATE_DATABASE_MANAGER_FEATURE["DATABASE_MANAGER_DELETE_DATABASE"] = "DATABASE_MANAGER_DELETE_DATABASE";
+})(IMBRICATE_DATABASE_MANAGER_FEATURE || (exports.IMBRICATE_DATABASE_MANAGER_FEATURE = IMBRICATE_DATABASE_MANAGER_FEATURE = {}));
+const checkImbricateDatabaseManagerFeatureSupported = (features, feature) => {
+    return features.includes(feature);
+};
+exports.checkImbricateDatabaseManagerFeatureSupported = checkImbricateDatabaseManagerFeatureSupported;

package/database-manager/outcome.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Outcome
+ */
+import { IImbricateDatabase } from "../database/interface";
+export declare const S_DatabaseManager_ListDatabases_Stale: unique symbol;
+export type ImbricateDatabaseManagerListDatabasesOutcomeSymbol = typeof S_DatabaseManager_ListDatabases_Stale;
+export type ImbricateDatabaseManagerListDatabasesOutcome = {
+    readonly databases: IImbricateDatabase[];
+} | ImbricateDatabaseManagerListDatabasesOutcomeSymbol;
+export declare const S_DatabaseManager_GetDatabase_NotFound: unique symbol;
+export type ImbricateDatabaseManagerGetDatabaseOutcomeSymbol = typeof S_DatabaseManager_GetDatabase_NotFound;
+export type ImbricateDatabaseManagerGetDatabaseOutcome = {
+    readonly database: IImbricateDatabase;
+} | ImbricateDatabaseManagerGetDatabaseOutcomeSymbol;
+export declare const S_DatabaseManager_CreateDatabase_IdentifierDuplicated: unique symbol;
+export type ImbricateDatabaseManagerCreateDatabaseOutcomeSymbol = typeof S_DatabaseManager_CreateDatabase_IdentifierDuplicated;
+export type ImbricateDatabaseManagerCreateDatabaseOutcome = {
+    readonly database: IImbricateDatabase;
+} | ImbricateDatabaseManagerCreateDatabaseOutcomeSymbol;
+export declare const S_DatabaseManager_RemoveDatabase_NotFound: unique symbol;
+export type ImbricateDatabaseManagerRemoveDatabaseOutcomeSymbol = typeof S_DatabaseManager_RemoveDatabase_NotFound;
+export type ImbricateDatabaseManagerRemoveDatabaseOutcome = {
+    readonly success: boolean;
+} | ImbricateDatabaseManagerRemoveDatabaseOutcomeSymbol;

package/database-manager/outcome.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace DatabaseManager
+ * @description Outcome
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S_DatabaseManager_RemoveDatabase_NotFound = exports.S_DatabaseManager_CreateDatabase_IdentifierDuplicated = exports.S_DatabaseManager_GetDatabase_NotFound = exports.S_DatabaseManager_ListDatabases_Stale = void 0;
+// Manager List Databases
+exports.S_DatabaseManager_ListDatabases_Stale = Symbol("DatabaseManager_ListDatabases_Stale");
+// Manager Get Database
+exports.S_DatabaseManager_GetDatabase_NotFound = Symbol("DatabaseManager_GetDatabase_NotFound");
+// Manager Create Database
+exports.S_DatabaseManager_CreateDatabase_IdentifierDuplicated = Symbol("DatabaseManager_CreateDatabase_IdentifierDuplicated");
+// Manager Remove Database
+exports.S_DatabaseManager_RemoveDatabase_NotFound = Symbol("DatabaseManager_RemoveDatabase_NotFound");

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

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential Readonly
+ */
+import { DocumentAnnotations, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentPutPropertyOutcome } from "../outcome";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+import { ImbricateDocumentEssentialBase } from "./essential";
+export declare abstract class ImbricateDocumentEssentialReadonlyBase extends ImbricateDocumentEssentialBase implements IImbricateDocument {
+    readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putProperty(_key: DocumentPropertyKey, _value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    putProperties(_properties: DocumentProperties, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentEssentialReadonlyBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const essential_1 = require("./essential");
+class ImbricateDocumentEssentialReadonlyBase extends essential_1.ImbricateDocumentEssentialBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [];
+    }
+    putProperty(_key, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+    putProperties(_properties, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+}
+exports.ImbricateDocumentEssentialReadonlyBase = ImbricateDocumentEssentialReadonlyBase;

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

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential
+ */
+import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentGetEditRecordsOutcome, ImbricateDocumentPutAnnotationOutcome } from "../outcome";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentEssentialBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putAnnotation(_namespace: string, _identifier: string, _value: DocumentAnnotationValue, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+    addEditRecords(_records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+    getEditRecords(): Promise<ImbricateDocumentGetEditRecordsOutcome>;
+}

package/document/base-class/essential.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentEssentialBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentEssentialBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+        ];
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION);
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD);
+    }
+    getEditRecords() {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD);
+    }
+}
+exports.ImbricateDocumentEssentialBase = ImbricateDocumentEssentialBase;

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

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Annotation
+ */
+import { DocumentAnnotationValue, DocumentAnnotations, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentPutAnnotationOutcome } from "../outcome";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentExcludeAnnotationBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putAnnotation(_namespace: string, _identifier: string, _value: DocumentAnnotationValue, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+}