@imbricate/core 3.7.2 → 3.8.0

package/.yarnrc.yml

@@ -0,0 +1,3 @@
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-4.4.0.cjs

package/babel.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+    presets: [
+        [
+            "@babel/preset-env",
+            {
+                targets:
+                {
+                    node: "current",
+                },
+            },
+        ],
+        "@babel/preset-typescript",
+    ],
+};

package/docs/README.md

@@ -0,0 +1,70 @@
+# Imbricate ▦
+
+```
+┌───────┐
+│ I M B │
+│ R I C │
+│ A T E │
+└───────┘
+```
+
+[![Continuous Integration](https://github.com/Imbricate/Imbricate/actions/workflows/ci.yml/badge.svg)](https://github.com/Imbricate/Imbricate/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/Imbricate/Imbricate/branch/main/graph/badge.svg)](https://codecov.io/gh/Imbricate/Imbricate)
+[![npm version](https://badge.fury.io/js/%40imbricate%2Fcore.svg)](https://badge.fury.io/js/%40imbricate%2Fcore)
+[![downloads](https://img.shields.io/npm/dm/@imbricate/core.svg)](https://www.npmjs.com/package/@imbricate/core)
+
+Yes to accountable notes, no to external hosting. Free, for everyone.
+
+## Install
+
+```sh
+yarn add @imbricate/core
+# Or
+npm install @imbricate/core --save
+```
+
+## Documentation
+
+Visit [imbricate.io](https://imbricate.io/).
+
+## Quick Start with Imbricate VSCode Extension
+
+Imbricate VSCode Extension is available through the Visual Studio Code Marketplace. See [Imbricate VSCode Extension](https://marketplace.visualstudio.com/items?itemName=imbricate.imbricate).
+
+## Quick Start with Imbricate CLI
+
+Imbricate CLI is available through NPM for package management. See https://github.com/imbricate/Imbricate-CLI.
+
+To install Imbricate CLI:
+
+### Using Yarn
+
+Yarn 1.x
+
+```sh
+yarn global add imbricate
+```
+
+Yarn 2.x
+
+```sh
+yarn dlx imbricate
+```
+
+### Using NPM
+
+```sh
+npm install -g imbricate
+```
+
+## Usage
+
+```sh
+imbricate --help
+```
+
+```
+┌─────────────────────┐
+│ I M B R I C A T E ▦ │
+└─────────────────────┘
+```

package/eslint.config.mjs

@@ -0,0 +1,64 @@
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import typescriptParser from "@typescript-eslint/parser";
+
+export default [
+    {
+        files: ["**/*.{ts,tsx}"],
+        languageOptions: {
+            parser: typescriptParser,
+            parserOptions: {
+                sourceType: "module",
+            },
+        },
+    },
+    {
+        plugins: {
+            "@typescript-eslint": typescriptEslint,
+        },
+        rules: {
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-unused-vars": [
+                "error",
+                {
+                    "argsIgnorePattern": "^_",
+                },
+            ],
+            "comma-dangle": [
+                "error",
+                {
+                    arrays: "always-multiline",
+                    objects: "always-multiline",
+                    functions: "always-multiline",
+                    imports: "always-multiline",
+                    exports: "always-multiline",
+                },
+            ],
+            "sort-imports": [
+                "error",
+                {
+                    ignoreCase: false,
+                    ignoreDeclarationSort: true,
+                    ignoreMemberSort: false,
+                    allowSeparatedGroups: false,
+                    memberSyntaxSortOrder: [
+                        "none",
+                        "all",
+                        "multiple",
+                        "single",
+                    ],
+                },
+            ],
+            quotes: [
+                "error",
+                "double",
+                {
+                    avoidEscape: true,
+                },
+            ],
+            semi: [
+                "error",
+                "always",
+            ],
+        },
+    },
+];

package/jest.config.ts

@@ -0,0 +1,14 @@
+import type { Config } from "jest";
+
+export default async (): Promise<Config> => {
+    return {
+        verbose: true,
+        collectCoverageFrom: [
+            "src/**/*.ts",
+        ],
+        coverageReporters: [
+            "json",
+            "text-summary",
+        ],
+    };
+};

package/package.json

@@ -1,8 +1,19 @@
 {
   "name": "@imbricate/core",
-  "main": "index.js",
-  "version": "3.7.2",
+  "packageManager": "yarn@4.4.0",
+  "version": "3.8.0",
   "description": "Imbricate Core, Notebook for Engineers",
+  "scripts": {
+    "clean": "rm -rf app",
+    "test": "jest",
+    "coverage": "jest --coverage",
+    "lint": "eslint src",
+    "build": "tsc --project typescript/tsconfig.build.json",
+    "license": "sdb license",
+    "release": "yarn lint && yarn test && yarn license && yarn build",
+    "publish-dry-run": "yarn release && sdb --only publish-dry-run",
+    "publish": "yarn release && sdb --only publish"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Imbricate/Imbricate.git"
@@ -17,5 +28,18 @@
   "bugs": {
     "url": "https://github.com/Imbricate/Imbricate/issues"
   },
-  "homepage": "https://imbricate.io"
+  "homepage": "https://imbricate.io",
+  "devDependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@types/jest": "^29.5.14",
+    "@typescript-eslint/eslint-plugin": "^8.16.0",
+    "@typescript-eslint/parser": "^8.16.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^9.15.0",
+    "jest": "^29.7.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  }
 }

package/{author/definition.d.ts → src/author/definition.ts}

@@ -3,9 +3,13 @@
  * @namespace Author
  * @description Definition
  */
+
 export type ImbricateAuthor = {
+
     readonly category: string;
     readonly identifier: string;
+
     readonly isAutomation: boolean;
+
     readonly onBehalfOf?: ImbricateAuthor;
 };

package/{database/definition.d.ts → src/database/definition.ts}

@@ -3,54 +3,117 @@
  * @namespace Database
  * @description Definition
  */
+
 import { ImbricateAuthor } from "../author/definition";
 import { ImbricateDatabaseSchema } from "./schema";
+
+export enum IMBRICATE_QUERY_COMPARE_CONDITION {
+
+    EQUAL = "EQUAL",
+}
+
+export enum IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET {
+
+    PROPERTY_TYPE = "PROPERTY_TYPE",
+    PROPERTY_VALUE = "PROPERTY_VALUE",
+}
+
+export type ImbricateDocumentQueryPropertyFilterCondition = {
+
+    readonly target: IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET;
+    readonly condition: IMBRICATE_QUERY_COMPARE_CONDITION;
+    readonly value: any;
+};
+
+export type ImbricateDocumentQueryPropertyFilter = {
+
+    readonly propertyIdentifier: string;
+    readonly conditions: ImbricateDocumentQueryPropertyFilterCondition[];
+};
+
+export type ImbricateDocumentQueryAnnotationFilter = {
+
+    readonly namespace: string;
+    readonly identifier: string;
+    readonly condition: IMBRICATE_QUERY_COMPARE_CONDITION;
+    readonly value: any;
+};
+
 /**
  * Query of the document
- *
+ * 
  * @param limit limit of the query
  * @param skip skip of the query
  */
 export type ImbricateDocumentQuery = {
+
     readonly limit?: number;
     readonly skip?: number;
+
+    readonly propertyFilters?: ImbricateDocumentQueryPropertyFilter[];
+    readonly annotationFilters?: ImbricateDocumentQueryAnnotationFilter[];
 };
+
 /**
  * Edit record type of the document
  */
-export declare enum IMBRICATE_DATABASE_EDIT_TYPE {
+export enum IMBRICATE_DATABASE_EDIT_TYPE {
+
     PUT_SCHEMA = "PUT_SCHEMA",
     PUT_ANNOTATION = "PUT_ANNOTATION",
-    DELETE_ANNOTATION = "DELETE_ANNOTATION"
+    DELETE_ANNOTATION = "DELETE_ANNOTATION",
 }
+
 export type DatabaseEditOperationPutAnnotation = {
+
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
+
     readonly data: any;
 };
+
 export type DatabaseEditOperationDeleteAnnotation = {
+
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
 };
-export type DatabaseEditOperationValue<T extends IMBRICATE_DATABASE_EDIT_TYPE> = T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_SCHEMA ? ImbricateDatabaseSchema : T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_ANNOTATION ? DatabaseEditOperationPutAnnotation : T extends IMBRICATE_DATABASE_EDIT_TYPE.DELETE_ANNOTATION ? DatabaseEditOperationDeleteAnnotation : never;
+
+// IMBRICATE_DATABASE_EDIT_TYPE SWITCH
+export type DatabaseEditOperationValue<T extends IMBRICATE_DATABASE_EDIT_TYPE> =
+    T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_SCHEMA ? ImbricateDatabaseSchema :
+    T extends IMBRICATE_DATABASE_EDIT_TYPE.PUT_ANNOTATION ? DatabaseEditOperationPutAnnotation :
+    T extends IMBRICATE_DATABASE_EDIT_TYPE.DELETE_ANNOTATION ? DatabaseEditOperationDeleteAnnotation :
+    never;
+
 export type DatabaseEditOperation<T extends IMBRICATE_DATABASE_EDIT_TYPE> = {
+
     readonly action: T;
     readonly value: DatabaseEditOperationValue<T>;
 };
+
 export type DatabaseEditRecord = {
+
     readonly uniqueIdentifier: string;
     readonly editAt: Date;
+
     readonly operations: Array<DatabaseEditOperation<IMBRICATE_DATABASE_EDIT_TYPE>>;
+
     readonly author?: ImbricateAuthor;
 };
+
 export type DatabaseAnnotations = Record<DatabaseAnnotationKey, DatabaseAnnotationValue>;
+
 export type DatabaseAnnotationKey = string;
 export type DatabaseAnnotationValue = {
+
     readonly namespace: string;
     readonly identifier: string;
+
     readonly data: any;
 };
+
 export type ImbricateDatabaseAuditOptions = {
+
     /**
      * Do not add edit record, this is controlled an function may vary by origin
      */

package/{database/interface.d.ts → src/database/interface.ts}

@@ -3,120 +3,162 @@
  * @namespace Database
  * @description Interface
  */
+
 import { IImbricateDocument } from "../document/interface";
 import { DocumentProperties } from "../document/property";
 import { DatabaseAnnotationValue, DatabaseAnnotations, DatabaseEditRecord, ImbricateDatabaseAuditOptions, ImbricateDocumentQuery } from "./definition";
 import { ImbricateDatabaseSchema } from "./schema";
+
 export interface IImbricateDatabase {
+
     /**
      * Unique identifier of the database
      */
     readonly uniqueIdentifier: string;
+
     /**
      * Name of the database
      */
     readonly databaseName: string;
+
     /**
      * Schema of the database
      */
     readonly schema: ImbricateDatabaseSchema;
+
     /**
      * Annotations of the database
      */
     readonly annotations: DatabaseAnnotations;
+
     /**
      * Put and replace the schema of the database
      *  Existing documents will still be kept, and stays unchanged
-     *
+     * 
      * @param schema schema of the database
-     * @param auditOptions audit options 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
      */
-    putSchema(schema: ImbricateDatabaseSchema, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
+    putSchema(
+        schema: ImbricateDatabaseSchema,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<DatabaseEditRecord[]>;
+
     /**
      * Create a new document in the database
      *  If origin supports Document Edit Record, the edit record will be added by default
-     *
+     * 
      * @param properties properties of the document
      * @param auditOptions audit options of the document
-     *
+     * 
      * @returns a promise of the created document
      */
-    createDocument(properties: DocumentProperties, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<IImbricateDocument>;
+    createDocument(
+        properties: DocumentProperties,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<IImbricateDocument>;
+
     /**
      * Get one document from the database
-     *
+     * 
      * @param uniqueIdentifier unique identifier of the document
-     *
+     * 
      * @returns a promise of the documents in the database, null if not found
      */
-    getDocument(uniqueIdentifier: string): PromiseLike<IImbricateDocument | null>;
+    getDocument(
+        uniqueIdentifier: string,
+    ): PromiseLike<IImbricateDocument | null>;
+
     /**
      * Query documents from the database
-     *
+     * 
      * @param query query of the documents
-     *
+     * 
      * @returns a promise of the documents in the database
      */
-    queryDocuments(query: ImbricateDocumentQuery): PromiseLike<IImbricateDocument[]>;
+    queryDocuments(
+        query: ImbricateDocumentQuery,
+    ): PromiseLike<IImbricateDocument[]>;
+
     /**
      * Count documents in the database
-     *
+     * 
      * @param query query of the documents
-     *
+     * 
      * @returns a promise of the count of the documents in the database
      */
-    countDocuments(query: ImbricateDocumentQuery): PromiseLike<number>;
+    countDocuments(
+        query: ImbricateDocumentQuery,
+    ): PromiseLike<number>;
+
     /**
      * Remove a document from the database
-     *
+     * 
      * @param uniqueIdentifier unique identifier of the document
      * @param auditOptions audit options of the document
      */
-    removeDocument(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<void>;
+    removeDocument(
+        uniqueIdentifier: string,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<void>;
+
     /**
      * put annotation to the database
-     *
+     * 
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param value value of the annotation
      * @param auditOptions audit options of the database
-     *
+     * 
      * @returns a promise of the edit records of the database
      *  Note: if the origin supports Document Edit Record, the edit record will be added by default
      *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
      */
-    putAnnotation(namespace: string, identifier: string, value: DatabaseAnnotationValue, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
+    putAnnotation(
+        namespace: string,
+        identifier: string,
+        value: DatabaseAnnotationValue,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<DatabaseEditRecord[]>;
+
     /**
      * Delete annotation from the database
-     *
+     * 
      * @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
      */
-    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<DatabaseEditRecord[]>;
+    deleteAnnotation(
+        namespace: string,
+        identifier: string,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<DatabaseEditRecord[]>;
+
     /**
      * Add edit records to the database, optional
      *  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
-     *
+     * 
      * @param records database edit records
      */
-    addEditRecords?(records: DatabaseEditRecord[]): PromiseLike<void>;
+    addEditRecords?(
+        records: DatabaseEditRecord[],
+    ): PromiseLike<void>;
+
     /**
      * Get edit records of the database, optional
      *  This method is optional, if not implemented, means the origin
      *  1. The origin does not support edit records
      *  2. The origin force to add edit records when put properties
-     *
+     * 
      * @returns a promise of the edit records of the database
      */
     getEditRecords?(): PromiseLike<DatabaseEditRecord[]>;

package/{database/manager.d.ts → src/database/manager.ts}

@@ -3,39 +3,54 @@
  * @namespace Database
  * @description Manager
  */
+
 import { ImbricateDatabaseAuditOptions } from "./definition";
 import { IImbricateDatabase } from "./interface";
 import { ImbricateDatabaseSchemaForCreation } from "./schema";
+
 export interface IImbricateDatabaseManager {
+
     /**
      * List all databases in the origin
-     *
+     * 
      * @returns a promise of the databases in the origin
      */
     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>;
+    getDatabase(
+        uniqueIdentifier: string,
+    ): PromiseLike<IImbricateDatabase | null>;
+
     /**
      * 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
      */
-    createDatabase(databaseName: string, schema: ImbricateDatabaseSchemaForCreation, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<IImbricateDatabase>;
+    createDatabase(
+        databaseName: string,
+        schema: ImbricateDatabaseSchemaForCreation,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<IImbricateDatabase>;
+
     /**
      * Remove a database from the origin
-     *
+     * 
      * @param uniqueIdentifier unique identifier of the database
      * @param auditOptions audit options of deletion
      */
-    removeDatabase(uniqueIdentifier: string, auditOptions?: ImbricateDatabaseAuditOptions): PromiseLike<void>;
+    removeDatabase(
+        uniqueIdentifier: string,
+        auditOptions?: ImbricateDatabaseAuditOptions,
+    ): PromiseLike<void>;
 }