@imbricate/core 3.0.0 → 3.0.1

package/database/interface.d.ts

@@ -3,8 +3,8 @@
  * @namespace Database
  * @description Interface
  */
-import { DocumentProperties } from "../document/definition";
 import { IImbricateDocument } from "../document/interface";
+import { DocumentProperties } from "../document/property";
 import { ImbricateDocumentQuery } from "./definition";
 import { ImbricateDatabaseSchema } from "./schema";
 export interface IImbricateDatabase {

package/database/manager.d.ts

@@ -4,14 +4,22 @@
  * @description Manager
  */
 import { IImbricateDatabase } from "./interface";
-import { ImbricateDatabaseSchema } from "./schema";
+import { ImbricateDatabaseSchemaForCreation } from "./schema";
 export interface IImbricateDatabaseManager {
     /**
-     * Get databases from the origin
+     * List all databases in the origin
      *
      * @returns a promise of the databases in the origin
      */
-    getDatabases(): PromiseLike<IImbricateDatabase[]>;
+    listDatabases(): PromiseLike<IImbricateDatabase[]>;
+    /**
+     * Get one database from the origin
+     *
+     * @param uniqueIdentifier unique identifier of the database
+     *
+     * @returns a promise of the database, null if not found
+     */
+    getDatabase(uniqueIdentifier: string): PromiseLike<IImbricateDatabase | null>;
     /**
      * Create a new database
      *
@@ -22,5 +30,5 @@ export interface IImbricateDatabaseManager {
      *
      * @returns a promise of the created database
      */
-    createDatabase(databaseName: string, schema: ImbricateDatabaseSchema, uniqueIdentifier?: string): PromiseLike<IImbricateDatabase>;
+    createDatabase(databaseName: string, schema: ImbricateDatabaseSchemaForCreation, uniqueIdentifier?: string): PromiseLike<IImbricateDatabase>;
 }

package/database/schema.d.ts

@@ -3,12 +3,35 @@
  * @namespace Database
  * @description Schema
  */
-import { IMBRICATE_PROPERTY_TYPE } from "../document/definition";
+import { IMBRICATE_PROPERTY_TYPE } from "../document/property";
 export type ImbricateDatabaseSchemaProperty = {
     readonly propertyIdentifier: string;
+} & ImbricateDatabaseSchemaPropertyForCreation;
+export type ImbricateDatabaseSchemaPropertyForCreation = {
     readonly propertyName: string;
     readonly propertyType: IMBRICATE_PROPERTY_TYPE;
 };
 export type ImbricateDatabaseSchema = {
     readonly properties: ImbricateDatabaseSchemaProperty[];
 };
+export type ImbricateDatabaseSchemaForCreation = {
+    readonly properties: ImbricateDatabaseSchemaPropertyForCreation[];
+};
+/**
+ * Validate a schema property
+ *
+ * @param property property to validate
+ *
+ * @returns a string error message if validation failed
+ *      null if validation passed
+ */
+export declare const validateImbricateSchemaProperty: (property: ImbricateDatabaseSchemaProperty) => string | null;
+/**
+ * Validate a schema
+ *
+ * @param schema database schema to validate
+ *
+ * @returns a string error message if validation failed
+ *    null if validation passed
+ */
+export declare const validateImbricateSchema: (schema: ImbricateDatabaseSchema) => string | null;

package/database/schema.js

@@ -5,3 +5,52 @@
  * @description Schema
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateImbricateSchema = exports.validateImbricateSchemaProperty = void 0;
+const property_1 = require("../document/property");
+/**
+ * Validate a schema property
+ *
+ * @param property property to validate
+ *
+ * @returns a string error message if validation failed
+ *      null if validation passed
+ */
+const validateImbricateSchemaProperty = (property) => {
+    if (typeof property.propertyIdentifier !== "string") {
+        return "Property identifier must be a string";
+    }
+    if (typeof property.propertyName !== "string") {
+        return "Property name must be a string";
+    }
+    if (!Object.values(property_1.IMBRICATE_PROPERTY_TYPE).includes(property.propertyType)) {
+        return "Property type must be a valid type";
+    }
+    return null;
+};
+exports.validateImbricateSchemaProperty = validateImbricateSchemaProperty;
+/**
+ * Validate a schema
+ *
+ * @param schema database schema to validate
+ *
+ * @returns a string error message if validation failed
+ *    null if validation passed
+ */
+const validateImbricateSchema = (schema) => {
+    if (!Array.isArray(schema.properties)) {
+        return "Properties must be an array";
+    }
+    const propertyNames = new Set();
+    for (const property of schema.properties) {
+        const propertyValidationResult = (0, exports.validateImbricateSchemaProperty)(property);
+        if (typeof propertyValidationResult === "string") {
+            return `Invalid property ${property.propertyName}, ${propertyValidationResult}`;
+        }
+        if (propertyNames.has(property.propertyName)) {
+            return `Duplicated property name ${property.propertyName}`;
+        }
+        propertyNames.add(property.propertyName);
+    }
+    return null;
+};
+exports.validateImbricateSchema = validateImbricateSchema;

package/document/definition.d.ts

@@ -4,19 +4,7 @@
  * @description Definition
  */
 import { ImbricateAuthor } from "../author/definition";
-export declare enum IMBRICATE_PROPERTY_TYPE {
-    STRING = "STRING",
-    MARKDOWN = "MARKDOWN"
-}
-export type DocumentProperties = Record<DocumentPropertyKey, DocumentPropertyValue>;
-export type DocumentPropertyKey = string;
-export type DocumentPropertyValue = {
-    readonly type: IMBRICATE_PROPERTY_TYPE;
-    readonly value: any;
-};
-export declare enum IMBRICATE_DOCUMENT_EDIT_TYPE {
-    PUT = "PUT"
-}
+import { DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_DOCUMENT_EDIT_TYPE } from "./property";
 export type DocumentEditOperation = {
     readonly key: DocumentPropertyKey;
     readonly action: IMBRICATE_DOCUMENT_EDIT_TYPE;

package/document/definition.js

@@ -5,13 +5,3 @@
  * @description Definition
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IMBRICATE_DOCUMENT_EDIT_TYPE = exports.IMBRICATE_PROPERTY_TYPE = void 0;
-var IMBRICATE_PROPERTY_TYPE;
-(function (IMBRICATE_PROPERTY_TYPE) {
-    IMBRICATE_PROPERTY_TYPE["STRING"] = "STRING";
-    IMBRICATE_PROPERTY_TYPE["MARKDOWN"] = "MARKDOWN";
-})(IMBRICATE_PROPERTY_TYPE || (exports.IMBRICATE_PROPERTY_TYPE = IMBRICATE_PROPERTY_TYPE = {}));
-var IMBRICATE_DOCUMENT_EDIT_TYPE;
-(function (IMBRICATE_DOCUMENT_EDIT_TYPE) {
-    IMBRICATE_DOCUMENT_EDIT_TYPE["PUT"] = "PUT";
-})(IMBRICATE_DOCUMENT_EDIT_TYPE || (exports.IMBRICATE_DOCUMENT_EDIT_TYPE = IMBRICATE_DOCUMENT_EDIT_TYPE = {}));

package/document/interface.d.ts

@@ -3,7 +3,8 @@
  * @namespace Document
  * @description Interface
  */
-import { DocumentEditRecord, DocumentProperties, DocumentPropertyKey, DocumentPropertyValue } from "./definition";
+import { DocumentEditRecord } from "./definition";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue } from "./property";
 export interface IImbricateDocument {
     /**
      * Unique identifier of the database

package/document/property.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Property
+ */
+export declare enum IMBRICATE_PROPERTY_TYPE {
+    STRING = "STRING",
+    MARKDOWN = "MARKDOWN"
+}
+export type DocumentProperties = Record<DocumentPropertyKey, DocumentPropertyValue>;
+export type DocumentPropertyKey = string;
+export type DocumentPropertyValue = {
+    readonly type: IMBRICATE_PROPERTY_TYPE;
+    readonly value: any;
+};
+export declare enum IMBRICATE_DOCUMENT_EDIT_TYPE {
+    PUT = "PUT"
+}

package/document/property.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Property
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMBRICATE_DOCUMENT_EDIT_TYPE = exports.IMBRICATE_PROPERTY_TYPE = void 0;
+var IMBRICATE_PROPERTY_TYPE;
+(function (IMBRICATE_PROPERTY_TYPE) {
+    IMBRICATE_PROPERTY_TYPE["STRING"] = "STRING";
+    IMBRICATE_PROPERTY_TYPE["MARKDOWN"] = "MARKDOWN";
+})(IMBRICATE_PROPERTY_TYPE || (exports.IMBRICATE_PROPERTY_TYPE = IMBRICATE_PROPERTY_TYPE = {}));
+var IMBRICATE_DOCUMENT_EDIT_TYPE;
+(function (IMBRICATE_DOCUMENT_EDIT_TYPE) {
+    IMBRICATE_DOCUMENT_EDIT_TYPE["PUT"] = "PUT";
+})(IMBRICATE_DOCUMENT_EDIT_TYPE || (exports.IMBRICATE_DOCUMENT_EDIT_TYPE = IMBRICATE_DOCUMENT_EDIT_TYPE = {}));

package/document/validate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Validate
+ */
+import { ImbricateDatabaseSchema } from "../database/schema";
+import { DocumentProperties } from "./property";
+/**
+ * Validate properties with schema
+ *
+ * @param properties properties to validate
+ * @param schema database schema to validate
+ *
+ * @returns a string error message if validation failed
+ *        null if validation passed
+ */
+export declare const validateImbricateProperties: (properties: DocumentProperties, schema: ImbricateDatabaseSchema) => string | null;

package/document/validate.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Validate
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateImbricateProperties = void 0;
+const property_1 = require("./property");
+/**
+ * Validate properties with schema
+ *
+ * @param properties properties to validate
+ * @param schema database schema to validate
+ *
+ * @returns a string error message if validation failed
+ *        null if validation passed
+ */
+const validateImbricateProperties = (properties, schema) => {
+    if (typeof properties !== "object") {
+        return "Properties must be an object";
+    }
+    const keys = Object.keys(properties);
+    for (const key of keys) {
+        const property = schema.properties.find((each) => {
+            return each.propertyName === key;
+        });
+        if (!property) {
+            return `Property ${key} not found in schema`;
+        }
+        const value = properties[key];
+        if (typeof value.type !== "string") {
+            return `Property ${key} type must be a string`;
+        }
+        if (value.type !== property.propertyType) {
+            return `Property ${key} type must be ${property.propertyType}, but got ${value.type}`;
+        }
+        switch (value.type) {
+            case property_1.IMBRICATE_PROPERTY_TYPE.STRING: {
+                if (typeof value.value !== "string") {
+                    return `Property ${key} value must be a string`;
+                }
+                break;
+            }
+            case property_1.IMBRICATE_PROPERTY_TYPE.MARKDOWN: {
+                if (typeof value.value !== "string") {
+                    return `Property ${key} value must be a string of text object reference`;
+                }
+                break;
+            }
+        }
+    }
+    return null;
+};
+exports.validateImbricateProperties = validateImbricateProperties;

package/index.d.ts

@@ -9,6 +9,8 @@ export * from "./database/manager";
 export * from "./database/schema";
 export * from "./document/definition";
 export * from "./document/interface";
+export * from "./document/property";
+export * from "./document/validate";
 export * from "./loader/definition";
 export * from "./loader/origin-loader";
 export * from "./loader/persistance";

package/index.js

@@ -25,6 +25,8 @@ __exportStar(require("./database/manager"), exports);
 __exportStar(require("./database/schema"), exports);
 __exportStar(require("./document/definition"), exports);
 __exportStar(require("./document/interface"), exports);
+__exportStar(require("./document/property"), exports);
+__exportStar(require("./document/validate"), exports);
 __exportStar(require("./loader/definition"), exports);
 __exportStar(require("./loader/origin-loader"), exports);
 __exportStar(require("./loader/persistance"), exports);

package/loader/origin-loader.d.ts

@@ -4,5 +4,6 @@
  * @description Origin Loader
  */
 import { IImbricateOrigin } from "../origin/interface";
-import { ImbricateOriginPersistance } from "./persistance";
+import { ImbricateOriginPersistance, ImbricateOriginPersistanceOrigin } from "./persistance";
+export declare const loadImbricateOriginFromPersistanceOrigin: (origin: ImbricateOriginPersistanceOrigin) => Promise<IImbricateOrigin | null>;
 export declare const loadImbricateOriginsFromPersistance: (persistance: ImbricateOriginPersistance) => Promise<IImbricateOrigin[]>;

package/loader/origin-loader.js

@@ -37,28 +37,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadImbricateOriginsFromPersistance = void 0;
+exports.loadImbricateOriginsFromPersistance = exports.loadImbricateOriginFromPersistanceOrigin = void 0;
 const persistance_1 = require("./persistance");
+const loadImbricateOriginFromPersistanceOrigin = (origin) => __awaiter(void 0, void 0, void 0, function* () {
+    switch (origin.originLoadType) {
+        case persistance_1.IMBRICATE_ORIGIN_LOAD_TYPE.NPM_PACKAGE: {
+            const originPackage = yield Promise.resolve(`${origin.originLoadValue}`).then(s => __importStar(require(s)));
+            if (typeof originPackage.default === "function") {
+                const initialized = originPackage.default.call(null, origin.originPayloads);
+                return initialized;
+            }
+            break;
+        }
+        case persistance_1.IMBRICATE_ORIGIN_LOAD_TYPE.FILE_SYSTEM: {
+            const originPackage = yield Promise.resolve(`${origin.originLoadValue}`).then(s => __importStar(require(s)));
+            if (typeof originPackage.default === "function") {
+                const initialized = originPackage.default.call(null, origin.originPayloads);
+                return initialized;
+            }
+            break;
+        }
+    }
+    return null;
+});
+exports.loadImbricateOriginFromPersistanceOrigin = loadImbricateOriginFromPersistanceOrigin;
 const loadImbricateOriginsFromPersistance = (persistance) => __awaiter(void 0, void 0, void 0, function* () {
     const origins = [];
     for (const origin of persistance.origins) {
-        switch (origin.originLoadType) {
-            case persistance_1.IMBRICATE_ORIGIN_LOAD_TYPE.NPM_PACKAGE: {
-                const originPackage = yield Promise.resolve(`${origin.originLoadValue}`).then(s => __importStar(require(s)));
-                if (typeof originPackage.default === "function") {
-                    const initialized = originPackage.default.call(null, origin.originPayloads);
-                    origins.push(initialized);
-                }
-                break;
-            }
-            case persistance_1.IMBRICATE_ORIGIN_LOAD_TYPE.FILE_SYSTEM: {
-                const originPackage = yield Promise.resolve(`${origin.originLoadValue}`).then(s => __importStar(require(s)));
-                if (typeof originPackage.default === "function") {
-                    const initialized = originPackage.default.call(null, origin.originPayloads);
-                    origins.push(initialized);
-                }
-                break;
-            }
+        const originInstance = yield (0, exports.loadImbricateOriginFromPersistanceOrigin)(origin);
+        if (originInstance) {
+            origins.push(originInstance);
         }
     }
     return origins;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imbricate/core",
   "main": "index.js",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Imbricate Core, Notebook for Engineers",
   "repository": {
     "type": "git",