@imbricate/core 3.1.2 → 3.2.1

package/database/schema.d.ts

@@ -4,18 +4,34 @@
  * @description Schema
  */
 import { IMBRICATE_PROPERTY_TYPE } from "../document/property";
-export type ImbricateDatabaseSchemaProperty = {
+export type ImbricateDatabaseSchemaProperty<T extends IMBRICATE_PROPERTY_TYPE> = {
     readonly propertyIdentifier: string;
-} & ImbricateDatabaseSchemaPropertyForCreation;
-export type ImbricateDatabaseSchemaPropertyForCreation = {
+} & ImbricateDatabaseSchemaPropertyForCreation<T>;
+export type ImbricateDatabaseSchemaPropertyOptionsReferenceDatabase = {
+    readonly originUniqueIdentifier: string;
+    readonly databaseUniqueIdentifier: string;
+};
+export type ImbricateDatabaseSchemaPropertyOptions<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? {} : T extends IMBRICATE_PROPERTY_TYPE.STRING ? {} : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? {} : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? {} : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? {
+    /**
+     * Allow multiple references
+     */
+    readonly allowMultiple: boolean;
+    /**
+     * Allow references from these databases
+     *  If empty, allow references from all databases
+     */
+    readonly databases: ImbricateDatabaseSchemaPropertyOptionsReferenceDatabase[];
+} : never;
+export type ImbricateDatabaseSchemaPropertyForCreation<T extends IMBRICATE_PROPERTY_TYPE> = {
     readonly propertyName: string;
-    readonly propertyType: IMBRICATE_PROPERTY_TYPE;
+    readonly propertyType: T;
+    readonly propertyOptions: ImbricateDatabaseSchemaPropertyOptions<T>;
 };
 export type ImbricateDatabaseSchema = {
-    readonly properties: ImbricateDatabaseSchemaProperty[];
+    readonly properties: Array<ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>>;
 };
 export type ImbricateDatabaseSchemaForCreation = {
-    readonly properties: ImbricateDatabaseSchemaPropertyForCreation[];
+    readonly properties: Array<ImbricateDatabaseSchemaPropertyForCreation<IMBRICATE_PROPERTY_TYPE>>;
 };
 /**
  * Validate a schema property
@@ -25,7 +41,7 @@ export type ImbricateDatabaseSchemaForCreation = {
  * @returns a string error message if validation failed
  *      null if validation passed
  */
-export declare const validateImbricateSchemaProperty: (property: ImbricateDatabaseSchemaProperty) => string | null;
+export declare const validateImbricateSchemaProperty: (property: ImbricateDatabaseSchemaProperty<IMBRICATE_PROPERTY_TYPE>) => string | null;
 /**
  * Validate a schema
  *

package/database/schema.js

@@ -25,6 +25,28 @@ const validateImbricateSchemaProperty = (property) => {
     if (!Object.values(property_1.IMBRICATE_PROPERTY_TYPE).includes(property.propertyType)) {
         return "Property type must be a valid type";
     }
+    switch (property.propertyType) {
+        case property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: {
+            if (typeof property.propertyOptions !== "object") {
+                return "Property options must be an object";
+            }
+            if (typeof property.propertyOptions.allowMultiple !== "boolean") {
+                return "Property options allowMultiple must be a boolean";
+            }
+            if (!Array.isArray(property.propertyOptions.databases)) {
+                return "Property options databases must be an array";
+            }
+            for (const database of property.propertyOptions.databases) {
+                if (typeof database.originUniqueIdentifier !== "string") {
+                    return "Database originUniqueIdentifier must be a string";
+                }
+                if (typeof database.databaseUniqueIdentifier !== "string") {
+                    return "Database databaseUniqueIdentifier must be a string";
+                }
+            }
+            break;
+        }
+    }
     return null;
 };
 exports.validateImbricateSchemaProperty = validateImbricateSchemaProperty;

package/document/property.d.ts

@@ -5,13 +5,29 @@
  */
 /**
  * Document properties
- *
- * STRING - string, store as plain text
- * MARKDOWN - markdown, store as text object unique identifier. Display as markdown
  */
 export declare enum IMBRICATE_PROPERTY_TYPE {
+    /**
+     * BOOLEAN - boolean, store as boolean
+     */
+    BOOLEAN = "BOOLEAN",
+    /**
+     * STRING - string, store as plain text
+     */
     STRING = "STRING",
-    MARKDOWN = "MARKDOWN"
+    /**
+     * NUMBER - number, store as number
+     */
+    NUMBER = "NUMBER",
+    /**
+     * MARKDOWN - markdown, store as text object unique identifier. Display as markdown
+     */
+    MARKDOWN = "MARKDOWN",
+    /**
+     * REFERENCE - reference, store as a list of other document unique identifier
+     *  Note: Reference is always stored as an array, even if it is a single reference
+     */
+    REFERENCE = "REFERENCE"
 }
 /**
  * Document properties
@@ -28,7 +44,12 @@ export type DocumentPropertyValue<T extends IMBRICATE_PROPERTY_TYPE> = {
     readonly type: T;
     readonly value: DocumentPropertyValueObject<T>;
 };
-export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string : never;
+export type DocumentPropertyValueObjectReference = {
+    readonly originUniqueIdentifier: string;
+    readonly databaseUniqueIdentifier: string;
+    readonly documentUniqueIdentifier: string;
+};
+export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean : T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? DocumentPropertyValueObjectReference[] : never;
 /**
  * Edit record type of the document
  */

package/document/property.js

@@ -8,14 +8,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IMBRICATE_DOCUMENT_EDIT_TYPE = exports.IMBRICATE_PROPERTY_TYPE = void 0;
 /**
  * Document properties
- *
- * STRING - string, store as plain text
- * MARKDOWN - markdown, store as text object unique identifier. Display as markdown
  */
 var IMBRICATE_PROPERTY_TYPE;
 (function (IMBRICATE_PROPERTY_TYPE) {
+    /**
+     * BOOLEAN - boolean, store as boolean
+     */
+    IMBRICATE_PROPERTY_TYPE["BOOLEAN"] = "BOOLEAN";
+    /**
+     * STRING - string, store as plain text
+     */
     IMBRICATE_PROPERTY_TYPE["STRING"] = "STRING";
+    /**
+     * NUMBER - number, store as number
+     */
+    IMBRICATE_PROPERTY_TYPE["NUMBER"] = "NUMBER";
+    /**
+     * MARKDOWN - markdown, store as text object unique identifier. Display as markdown
+     */
     IMBRICATE_PROPERTY_TYPE["MARKDOWN"] = "MARKDOWN";
+    /**
+     * REFERENCE - reference, store as a list of other document unique identifier
+     *  Note: Reference is always stored as an array, even if it is a single reference
+     */
+    IMBRICATE_PROPERTY_TYPE["REFERENCE"] = "REFERENCE";
 })(IMBRICATE_PROPERTY_TYPE || (exports.IMBRICATE_PROPERTY_TYPE = IMBRICATE_PROPERTY_TYPE = {}));
 /**
  * Edit record type of the document

package/document/validate.js

@@ -36,18 +36,50 @@ const validateImbricateProperties = (properties, schema) => {
             return `Property ${key} type must be ${property.propertyType}, but got ${value.type}`;
         }
         switch (value.type) {
+            case property_1.IMBRICATE_PROPERTY_TYPE.BOOLEAN: {
+                if (typeof value.value !== "boolean") {
+                    return `Property ${key} value must be a boolean`;
+                }
+                break;
+            }
             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.NUMBER: {
+                if (typeof value.value !== "number") {
+                    return `Property ${key} value must be a number`;
+                }
+                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;
             }
+            case property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: {
+                if (!Array.isArray(value.value)) {
+                    return `Property ${key} value must be an array of string`;
+                }
+                for (const reference of value.value) {
+                    if (typeof reference !== "object") {
+                        return `Property ${key} reference must be an object`;
+                    }
+                    if (typeof reference.originUniqueIdentifier !== "string") {
+                        return `Property ${key} reference originUniqueIdentifier must be a string`;
+                    }
+                    if (typeof reference.databaseUniqueIdentifier !== "string") {
+                        return `Property ${key} reference databaseUniqueIdentifier must be a string`;
+                    }
+                    if (typeof reference.documentUniqueIdentifier !== "string") {
+                        return `Property ${key} reference documentUniqueIdentifier must be a string`;
+                    }
+                }
+                break;
+            }
         }
     }
     return null;

package/loader/origin-loader.js

@@ -20,13 +20,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {

package/package.json

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