@acodeninja/persist 2.1.1 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acodeninja/persist",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "description": "A JSON based data modelling and persistence module with alternate storage mechanisms.",
   "type": "module",
   "scripts": {
@@ -26,6 +26,7 @@
     "ajv": "^8.16.0",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^3.0.1",
+    "lodash": "^4.17.21",
     "lunr": "^2.3.9",
     "slugify": "^1.6.6",
     "ulid": "^2.3.0"
@@ -43,7 +44,6 @@
     "eslint": "^9.6.0",
     "globals": "^15.8.0",
     "husky": "^9.1.1",
-    "lodash": "^4.17.21",
     "monocart-coverage-reports": "^2.10.2",
     "semantic-release": "^24.0.0",
     "sinon": "^18.0.0"

package/src/Query.js

@@ -0,0 +1,62 @@
+/**
+ * persist query language features:
+ * - value match {title: 'test'} or {title: {$is: 'test'}}
+ * - contains match {list: {$contains: 'test'}} or {string: {$contains: 'es'}}
+ * - nested query {list: {$contains: {slug: 'test'}}}
+ * - deep nesting queries {list: {$contains: {string: {$contains: 'test'}}}}
+ */
+
+/**
+ * @class Query
+ */
+class Query {
+    query;
+
+    /**
+     *
+     * @param {object} query
+     */
+    constructor(query) {
+        this.query = query;
+    }
+
+    /**
+     * Using the input query, find records in an index that match
+     *
+     * @param {typeof Model} model
+     * @param {object} index
+     */
+    execute(model, index) {
+        const matchIs = (query) => !!query?.$is;
+        const matchPrimitive = (query) => ['string', 'number', 'boolean'].includes(typeof query);
+        const matchContains = (query) => !!query?.$contains;
+
+        const matchesQuery = (subject, inputQuery = this.query) => {
+            if (!subject || !inputQuery) return false;
+
+            if (matchPrimitive(inputQuery)) return subject === inputQuery;
+
+            if (matchIs(inputQuery))
+                if (subject === inputQuery.$is) return true;
+
+            if (matchContains(inputQuery)) {
+                if (subject.includes?.(inputQuery.$contains)) return true;
+
+                for (const value of subject) {
+                    if (matchesQuery(value, inputQuery.$contains)) return true;
+                }
+            }
+
+            for (const key of Object.keys(inputQuery)) {
+                if (!['$is', '$contains'].includes(key))
+                    if (matchesQuery(subject[key], inputQuery[key])) return true;
+            }
+        };
+
+        return Object.values(index)
+            .filter(m => matchesQuery(m))
+            .map(m => model.fromData(m));
+    }
+}
+
+export default Query;

package/src/engine/Engine.js

@@ -1,3 +1,4 @@
+import Query from '../Query.js';
 import Type from '../type/index.js';
 import lunr from 'lunr';
 
@@ -15,6 +16,10 @@ export default class Engine {
         throw new NotImplementedError(`${this.name} must implement .putModel()`);
     }
 
+    static async getIndex(_model) {
+        throw new NotImplementedError(`${this.name} does not implement .getIndex()`);
+    }
+
     static async putIndex(_index) {
         throw new NotImplementedError(`${this.name} does not implement .putIndex()`);
     }
@@ -35,10 +40,6 @@ export default class Engine {
         throw new NotImplementedError(`${this.name} does not implement .putSearchIndexRaw()`);
     }
 
-    static async findByValue(_model, _parameters) {
-        throw new NotImplementedError(`${this.name} does not implement .findByValue()`);
-    }
-
     static async search(model, query) {
         this.checkConfiguration();
 
@@ -61,10 +62,11 @@ export default class Engine {
         return output;
     }
 
-    static async find(model, parameters) {
+    static async find(model, query) {
         this.checkConfiguration();
-        const response = await this.findByValue(model, parameters);
-        return response.map(m => model.fromData(m));
+        const index = await this.getIndex(model);
+
+        return new Query(query).execute(model, index);
     }
 
     static async put(model) {

package/src/engine/FileEngine.js

@@ -31,14 +31,8 @@ export default class FileEngine extends Engine {
         return JSON.parse(await this._configuration.filesystem.readFile(filePath).then(f => f.toString()));
     }
 
-    static async findByValue(model, parameters) {
-        const index = JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_index.json')).catch(() => '{}')).toString());
-
-        return Object.values(index)
-            .filter((model) =>
-                Object.entries(parameters)
-                    .some(([name, value]) => model[name] === value),
-            );
+    static async getIndex(model) {
+        return JSON.parse((await this._configuration.filesystem.readFile(join(this._configuration.path, model.name, '_index.json')).catch(() => '{}')).toString());
     }
 
     static async putModel(model) {

package/src/engine/HTTPEngine.js

@@ -75,15 +75,6 @@ export default class HTTPEngine extends Engine {
         return await this._processFetch(url, this._getReadOptions());
     }
 
-    static async findByValue(model, parameters) {
-        const index = await this.getIndex(model.name);
-        return Object.values(index)
-            .filter((model) =>
-                Object.entries(parameters)
-                    .some(([name, value]) => model[name] === value),
-            );
-    }
-
     static async putModel(model) {
         const url = new URL([
             this._configuration.host,

package/src/engine/S3Engine.js

@@ -24,16 +24,6 @@ export default class S3Engine extends Engine {
         return JSON.parse(await data.Body.transformToString());
     }
 
-    static async findByValue(model, parameters) {
-        const index = await this.getIndex(model.name);
-
-        return Object.values(index)
-            .filter((model) =>
-                Object.entries(parameters)
-                    .some(([name, value]) => model[name] === value),
-            );
-    }
-
     static async putModel(model) {
         const Key = [this._configuration.prefix, `${model.id}.json`].join('/');
 

package/src/type/Model.js

@@ -1,5 +1,6 @@
 import SchemaCompiler from '../SchemaCompiler.js';
 import StringType from './simple/StringType.js';
+import _ from 'lodash';
 import {monotonicFactory} from 'ulid';
 
 const createID = monotonicFactory();
@@ -47,13 +48,31 @@ export default class Model {
     }
 
     toIndexData() {
-        const indexData = {id: this.id};
+        const output = { id: this.id };
+        const index = this.constructor.indexedProperties();
 
-        for (const name of this.constructor.indexedProperties()) {
-            indexData[name] = this[name];
+        for (const key of index) {
+            if (_.has(this, key)) {
+                _.set(output, key, _.get(this, key));
+            }
+
+            if (key.includes('[*]')) {
+                const segments = key.split('.');
+
+                const preWildcard = segments.slice(0, segments.indexOf('[*]'));
+                const postWildcard = segments.slice(segments.indexOf('[*]') + 1);
+
+                _.set(
+                    output,
+                    preWildcard,
+                    _.get(this, preWildcard, [])
+                        .map((e, i) =>
+                            _.set(_.get(output, preWildcard, [])[i] ?? {}, postWildcard, _.get(e, postWildcard))),
+                );
+            }
         }
 
-        return indexData;
+        return output;
     }
 
     toSearchData() {