add custom mapping exemple

Author: gregblt

example/custom-field-mapping/custom-field-mapping-example.js

@@ -0,0 +1,124 @@
+const { createActiveRecordEntity, DataSource } = require('nosqlax');
+
+const schema = {
+    "$id": "my-schema",
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "definitions": {
+        "address": {
+            "type": "object",
+            "properties": {
+                "city": { "type": "string" }
+            }
+        }
+    },
+    "properties": {
+        "name": { "type": "string" },
+        "address": {
+            "$ref": "#/definitions/address"
+        }
+    }
+}
+
+// Datasource (connexion)
+const ds = new DataSource({
+    url: 'http://localhost:5984',
+    database: 'nosqlax-test'
+})
+
+// Create the User class using the helper
+const User = createActiveRecordEntity(
+    "User",
+    "user",
+    schema,
+    ds,
+    {
+
+        methods: {
+            async findByCity(city) {
+                return this.findOne({ city: { $eq: city } });
+            },
+            async getViewA(options) {
+                return this.dbConnection.view('design', 'view', options)
+                // you can also process view results here to return User entities
+            }
+        },
+        fieldMap: {
+            type: "doctype",
+            city: "address.city"
+        }
+
+    })
+
+// Instanciate a user
+const user = new User({ name: "John Custom Field" });
+user.city = "Lyon"
+
+// { name: 'John Custom Field', city: 'Lyon' }
+console.log(user.toJSON())
+
+
+// Define a service class using your entity
+class UserService {
+
+    constructor(UserClass) {
+        this.UserClass = UserClass;
+    }
+
+
+    async findUserByCity(name) {
+        return await this.UserClass.findByCity(name);
+    }
+
+    async findUserByEmailAndName(email, name) {
+        return await this.UserClass.findOne({
+            "$and": [
+                { "name": name },
+                { "email": email }
+            ]
+        }
+        )
+
+    }
+
+    async getUserById(id) {
+        // Fetch a user by ID
+        return await this.UserClass.find(id);
+    }
+
+    async deleteUser(id) {
+        // Delete a user by ID
+        return await this.UserClass.delete(id);
+    }
+}
+
+// instantiate service
+
+const myService = new UserService(User);
+
+
+async function main() {
+    await user.save();
+    // Document like this will be created in DB:
+    /* {
+        "_id": "f9d62b31017e03b71fb0a84a5e000a08",
+            "_rev": "1-8d43f9216da5ae302f393886daa52765",
+                "name": "John Active",
+                    "address": {
+            "city": "Lyon"
+        },
+        "type": "user"
+    } */
+
+    const found = await myService.findUserByCity("Lyon");
+    console.log(found.toJSON());
+    /*     {
+  city: 'Lyon',
+  name: 'John Custom Field',
+  _id: 'f9d62b31017e03b71fb0a84a5e00f512',
+  _rev: '1-2b06619c969d53f4afb28765595b9a5f'
+}
+   */
+}
+
+main();

package.json

@@ -15,7 +15,8 @@
     "build": "tsc",
     "watch": "tsc --watch",
     "data-mapper-basic-example": "node example/basic-example/data-mapper-basic-example.js",
-    "active-record-basic-example": "node example/basic-example/active-record-basic-example.js"
+    "active-record-basic-example": "node example/basic-example/active-record-basic-example.js",
+    "custom-field-mapping-example": "node example/custom-field-mapping/custom-field-mapping-example.js"
   },
   "keywords": [
     "couchdb",

src/core/BaseEntity.ts

@@ -14,17 +14,35 @@ interface IBaseEntity {
 }
 import Ajv, { ValidateFunction, ErrorObject, AnySchema, AnySchemaObject } from 'ajv';
 
+function resolveRef(ref: string, definitions: Record<string, any>): any {
+  const match = ref.match(/^#\/definitions\/(.+)$/);
+  if (!match) throw new Error(`Unsupported $ref format: ${ref}`);
+  const key = match[1];
+  const resolved = definitions[key];
+  if (!resolved) throw new Error(`Could not resolve $ref: ${ref}`);
+  return resolved;
+}
+
 function collectAndRemoveAllSchemas(
   schema: any,
   path: string[],
   key: string,
-  results: any[]
+  results: any[],
+  definitions: Record<string, any>
 ): void {
   if (!schema || typeof schema !== 'object') return;
 
-  // Base case: found the key
+  // 🔁 If it's a $ref, resolve it
+  if (typeof schema === 'object' && schema.$ref) {
+    schema = resolveRef(schema.$ref, definitions);
+  }
+
+  // Base case: found the key in properties
   if (path.length === 0 && schema.properties?.[key]) {
-    results.push(schema.properties[key]);
+    let fieldSchema = schema.properties[key];
+
+
+    results.push(fieldSchema);
     delete schema.properties[key];
 
     if (Array.isArray(schema.required)) {
@@ -35,38 +53,38 @@ function collectAndRemoveAllSchemas(
 
   const [next, ...rest] = path;
 
-  // Dive into nested property
+  // Dive into nested propertiess
   if (schema.properties?.[next]) {
-    collectAndRemoveAllSchemas(schema.properties[next], rest, key, results);
+    collectAndRemoveAllSchemas(schema.properties[next], rest, key, results, definitions);
   }
 
-  // Dive into oneOf / anyOf / allOf branches
+  // Dive into oneOf / anyOf / allOf
   for (const comb of ['oneOf', 'anyOf', 'allOf']) {
     if (Array.isArray(schema[comb])) {
       for (const subSchema of schema[comb]) {
-        collectAndRemoveAllSchemas(subSchema, path, key, results);
+        collectAndRemoveAllSchemas(subSchema, path, key, results, definitions);
       }
     }
   }
 }
 
-
 function restructureSchemaFromFieldMap(
   schema: AnySchemaObject,
   fieldMap: Record<string, string>
 ): AnySchemaObject {
   const cloned = JSON.parse(JSON.stringify(schema));
+  const definitions = cloned.definitions || {};
   const toAdd: Record<string, any> = {};
 
   for (const [aliasName, fieldPath] of Object.entries(fieldMap)) {
     const parts = fieldPath.split('.');
     if (parts.length <= 1) continue;
 
-    const propKey = parts.pop()!; // use non-null assertion
+    const propKey = parts.pop()!;
     const parentPath = parts;
 
     const collectedSchemas: any[] = [];
-    collectAndRemoveAllSchemas(cloned, parentPath, propKey, collectedSchemas);
+    collectAndRemoveAllSchemas(cloned, parentPath, propKey, collectedSchemas, definitions);
 
     if (collectedSchemas.length === 1) {
       toAdd[aliasName] = collectedSchemas[0];
@@ -139,14 +157,16 @@ abstract class BaseEntity implements IBaseEntity {
       reverseMap[path] = alias;
     }
 
-    schema = restructureSchemaFromFieldMap(rawSchema, fieldMap);
+    // compile to dereference the schema
+    const validator =ajv.compile(rawSchema);
+    const resolvedSchema = validator.schema as AnySchemaObject;
+    restructureSchemaFromFieldMap(rawSchema, fieldMap);
 
     const schemaProperties = schema.properties || {};
     const schemaDefs: any = schema.definitions;
 
     for (const [schemaProp, schemaDef] of Object.entries(schemaProperties)) {
       const propName = reverseMap[schemaProp] || schemaProp;
-      
       // Inject definitions into subschema if needed
       if (typeof schemaDef === 'object' && schemaDefs) {
         (schemaDef as any).definitions = schemaDefs;