@drax/crud-back 3.1.0 → 3.4.1

package/dist/repository/AbstractSqliteRepository.js

@@ -6,6 +6,7 @@ class AbstractSqliteRepository {
         this.tableName = '';
         this.searchFields = [];
         this.booleanFields = [];
+        this.jsonFields = [];
         this.identifier = '_id';
         if (!dataBaseFile) {
             throw new Error("dataBaseFile is required");
@@ -30,6 +31,67 @@ class AbstractSqliteRepository {
     async prepareItem(item) {
         return item;
     }
+    parseJsonValue(value) {
+        if (typeof value !== 'string') {
+            return value;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    normalizeSqliteValue(value) {
+        if (value === undefined) {
+            return null;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 1 : 0;
+        }
+        if (typeof value === 'number' || typeof value === 'string' || typeof value === 'bigint') {
+            return value;
+        }
+        if (Buffer.isBuffer(value)) {
+            return value;
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (value instanceof ArrayBuffer) {
+            return Buffer.from(value);
+        }
+        if (ArrayBuffer.isView(value)) {
+            return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+    normalizeSqliteData(data) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        for (const key of Object.keys(data)) {
+            data[key] = this.normalizeSqliteValue(data[key]);
+        }
+        return data;
+    }
+    deserializeSqliteData(item) {
+        if (!item || typeof item !== 'object') {
+            return item;
+        }
+        for (const field of this.jsonFields) {
+            if (Object.prototype.hasOwnProperty.call(item, field)) {
+                item[field] = this.parseJsonValue(item[field]);
+            }
+        }
+        return item;
+    }
     async execPopulate(item) {
         for (const field of this.populateFields) {
             if (item[field.field]) {
@@ -49,6 +111,7 @@ class AbstractSqliteRepository {
     }
     async decorate(item) {
         await this.execPopulate(item);
+        this.deserializeSqliteData(item);
         this.castToBoolean(item);
         await this.prepareItem(item);
     }
@@ -57,11 +120,6 @@ class AbstractSqliteRepository {
             if (!data[this.identifier]) {
                 data[this.identifier] = randomUUID();
             }
-            for (const key in data) {
-                if (typeof data[key] === 'boolean') {
-                    data[key] = data[key] ? 1 : 0;
-                }
-            }
             if (this.hasCreatedAt()) {
                 data.createdAt = (new Date().toISOString());
             }
@@ -69,6 +127,7 @@ class AbstractSqliteRepository {
                 data.updatedAt = (new Date().toISOString());
             }
             await this.prepareData(data);
+            this.normalizeSqliteData(data);
             const fields = Object.keys(data)
                 .map(field => `${field}`)
                 .join(', ');
@@ -82,7 +141,7 @@ class AbstractSqliteRepository {
             return item;
         }
         catch (e) {
-            console.error(e);
+            console.error("sqlite create", e);
             throw SqliteErrorToValidationError(e, data);
         }
     }
@@ -91,15 +150,11 @@ class AbstractSqliteRepository {
     }
     async update(id, data) {
         try {
-            for (const key in data) {
-                if (typeof data[key] === 'boolean') {
-                    data[key] = data[key] ? 1 : 0;
-                }
-            }
             if (this.hasUpdatedAt()) {
                 data.updatedAt = (new Date().toISOString());
             }
             await this.prepareData(data);
+            this.normalizeSqliteData(data);
             const setClauses = Object.keys(data)
                 .map(field => `${field} = @${field}`)
                 .join(', ');
@@ -159,12 +214,14 @@ class AbstractSqliteRepository {
         for (const item of items) {
             await this.decorate(item);
         }
-        return {
+        const pagination = {
             page,
             limit,
             total: rCount.count,
             items
         };
+        console.log('Pagination result:', JSON.stringify(pagination, null, 4));
+        return pagination;
     }
     async find({ limit = 5, orderBy = '', order = 'desc', search = '', filters = [] }) {
         let where = "";
@@ -219,6 +276,9 @@ class AbstractSqliteRepository {
         return items;
     }
     async findById(id) {
+        if (id === undefined || id === null) {
+            return null;
+        }
         const item = this.db.prepare(`SELECT *
                                       FROM ${this.tableName}
                                       WHERE ${this.identifier} = ?`).get(id);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.1.0",
+  "version": "3.4.1",
   "description": "Crud utils across modules",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -25,7 +25,7 @@
     "@drax/common-back": "^3.0.0",
     "@drax/common-share": "^3.0.0",
     "@drax/identity-share": "^3.0.0",
-    "@drax/media-back": "^3.1.0",
+    "@drax/media-back": "^3.4.1",
     "@graphql-tools/load-files": "^7.0.0",
     "@graphql-tools/merge": "^9.0.4",
     "mongoose": "^8.23.0",
@@ -47,5 +47,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
-  "gitHead": "262ea8f861c84ca1ad4d555545c5a94b95dbf25e"
+  "gitHead": "bd93239e7b1cc56f1a12d9cb28ea5d87cda48c07"
 }

package/src/repository/AbstractSqliteRepository.ts

@@ -23,6 +23,7 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
     protected tableName: string = '';
     protected searchFields: string[] = [];
     protected booleanFields: string[] = [];
+    protected jsonFields: string[] = [];
     protected identifier: string = '_id';
     protected populateFields: { field: string, table: string, identifier: string }[]
     protected tableFields: SqliteTableField[];
@@ -59,6 +60,84 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
         return item
     }
 
+    protected parseJsonValue(value: any): any {
+        if (typeof value !== 'string') {
+            return value
+        }
+
+        try {
+            return JSON.parse(value)
+        } catch {
+            return value
+        }
+    }
+
+    protected normalizeSqliteValue(value: any): any {
+        if (value === undefined) {
+            return null
+        }
+
+        if (value === null) {
+            return null
+        }
+
+        if (typeof value === 'boolean') {
+            return value ? 1 : 0
+        }
+
+        if (typeof value === 'number' || typeof value === 'string' || typeof value === 'bigint') {
+            return value
+        }
+
+        if (Buffer.isBuffer(value)) {
+            return value
+        }
+
+        if (value instanceof Date) {
+            return value.toISOString()
+        }
+
+        if (value instanceof ArrayBuffer) {
+            return Buffer.from(value)
+        }
+
+        if (ArrayBuffer.isView(value)) {
+            return Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+        }
+
+        if (typeof value === 'object') {
+            return JSON.stringify(value)
+        }
+
+        return String(value)
+    }
+
+    protected normalizeSqliteData(data: any): any {
+        if (!data || typeof data !== 'object') {
+            return data
+        }
+
+        for (const key of Object.keys(data)) {
+            data[key] = this.normalizeSqliteValue(data[key])
+        }
+
+        return data
+    }
+
+    protected deserializeSqliteData(item: any): any {
+        if (!item || typeof item !== 'object') {
+            return item
+        }
+
+        for (const field of this.jsonFields) {
+            if (Object.prototype.hasOwnProperty.call(item, field)) {
+                item[field] = this.parseJsonValue(item[field])
+            }
+        }
+
+        return item
+    }
+
     async execPopulate(item: any) {
         for (const field of this.populateFields) {
             if (item[field.field]) {
@@ -81,10 +160,13 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
 
     async decorate(item: any) {
         await this.execPopulate(item)
+        this.deserializeSqliteData(item)
         this.castToBoolean(item)
         await this.prepareItem(item)
     }
 
+
+
     async create(data: any): Promise<T> {
         try {
 
@@ -92,12 +174,6 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
                 data[this.identifier] = randomUUID()
             }
 
-            for (const key in data) {
-                if (typeof data[key] === 'boolean') {
-                    data[key] = data[key] ? 1 : 0
-                }
-            }
-
             if (this.hasCreatedAt()) {
                 data.createdAt = (new Date().toISOString())
             }
@@ -106,7 +182,10 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
                 data.updatedAt = (new Date().toISOString())
             }
 
+
+
             await this.prepareData(data)
+            this.normalizeSqliteData(data)
 
             const fields = Object.keys(data)
                 .map(field => `${field}`)
@@ -124,7 +203,7 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
             return item
 
         } catch (e) {
-            console.error(e)
+            console.error("sqlite create",e)
             throw SqliteErrorToValidationError(e, data)
         }
     }
@@ -137,17 +216,12 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
     async update(id: string, data: any): Promise<T> {
         try {
 
-            for (const key in data) {
-                if (typeof data[key] === 'boolean') {
-                    data[key] = data[key] ? 1 : 0
-                }
-            }
-
             if (this.hasUpdatedAt()) {
                 data.updatedAt = (new Date().toISOString())
             }
 
             await this.prepareData(data)
+            this.normalizeSqliteData(data)
 
             const setClauses = Object.keys(data)
                 .map(field => `${field} = @${field}`)
@@ -237,12 +311,14 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
             await this.decorate(item)
         }
 
-        return {
+        const pagination = {
             page,
             limit,
             total: rCount.count,
             items
         }
+        console.log('Pagination result:', JSON.stringify(pagination,null,4))
+        return pagination
     }
 
     async find({
@@ -327,6 +403,10 @@ class AbstractSqliteRepository<T, C, U> implements IDraxCrud<T, C, U> {
     }
 
     async findById(id: string): Promise<T | null> {
+        if (id === undefined || id === null) {
+            return null
+        }
+
         const item = this.db.prepare(`SELECT *
                                       FROM ${this.tableName}
                                       WHERE ${this.identifier} = ?`).get(id);

package/test/people/repository/sqlite/LanguageSqliteRepository.ts

@@ -11,6 +11,7 @@ class LanguageSqliteRepository extends AbstractSqliteRepository<ILanguage, ILang
     protected dataBaseFile: string;
     protected searchFields: string[] = ['name'];
     protected booleanFields: string[] = [];
+    protected jsonFields: string[] = ['icon'];
     protected identifier: string = '_id';
     protected populateFields = [
 
@@ -25,13 +26,7 @@ class LanguageSqliteRepository extends AbstractSqliteRepository<ILanguage, ILang
     async prepareData(data: any): Promise<any> {
         data.icon = JSON.stringify(data.icon)
     }
-
-    async prepareItem(item: any): Promise<any> {
-        item.icon = JSON.parse(item.icon)
-    }
-
 }
 
 export default LanguageSqliteRepository
 export {LanguageSqliteRepository}
-

package/test/repository/AbstractSqliteRepository.test.ts

@@ -0,0 +1,95 @@
+import {describe, test} from "node:test";
+import assert from "node:assert/strict";
+import {randomUUID} from "node:crypto";
+import {AbstractSqliteRepository} from "../../src/index.js";
+import type {SqliteTableField} from "@drax/common-back";
+
+class TestSqliteRepository extends AbstractSqliteRepository<any, any, any> {
+    protected tableName: string = "TestEntity";
+    protected searchFields: string[] = [];
+    protected booleanFields: string[] = ["enabled"];
+    protected jsonFields: string[] = ["payload", "tags"];
+    protected identifier: string = "_id";
+    protected populateFields = [];
+    protected tableFields: SqliteTableField[] = [
+        {name: "title", type: "TEXT", unique: false, primary: false},
+        {name: "payload", type: "TEXT", unique: false, primary: false},
+        {name: "tags", type: "TEXT", unique: false, primary: false},
+        {name: "enabled", type: "INTEGER", unique: false, primary: false},
+        {name: "bornAt", type: "TEXT", unique: false, primary: false},
+        {name: "optional", type: "TEXT", unique: false, primary: false},
+        {name: "createdAt", type: "TEXT", unique: false, primary: false},
+        {name: "updatedAt", type: "TEXT", unique: false, primary: false}
+    ];
+
+    findRawById(id: string) {
+        return this.db.prepare(`SELECT * FROM ${this.tableName} WHERE ${this.identifier} = ?`).get(id);
+    }
+}
+
+describe("AbstractSqliteRepository", () => {
+    test("create should normalize non-bindable sqlite values", async () => {
+        const repository = new TestSqliteRepository(`/tmp/${randomUUID()}.db`);
+        repository.build();
+
+        const bornAt = new Date("2024-01-02T03:04:05.000Z");
+
+        const created = await repository.create({
+            title: "example",
+            payload: {foo: "bar", count: 2},
+            tags: ["a", "b"],
+            enabled: true,
+            bornAt,
+            optional: undefined
+        });
+
+        const raw = repository.findRawById(created._id);
+
+        assert.deepEqual(created.payload, {foo: "bar", count: 2});
+        assert.deepEqual(created.tags, ["a", "b"]);
+        assert.equal(created.enabled, true);
+        assert.equal(created.bornAt, bornAt.toISOString());
+        assert.equal(created.optional, null);
+        assert.equal(raw.title, "example");
+        assert.equal(raw.payload, JSON.stringify({foo: "bar", count: 2}));
+        assert.equal(raw.tags, JSON.stringify(["a", "b"]));
+        assert.equal(raw.enabled, 1);
+        assert.equal(raw.bornAt, bornAt.toISOString());
+        assert.equal(raw.optional, null);
+        assert.ok(typeof raw.createdAt === "string");
+        assert.ok(typeof raw.updatedAt === "string");
+    });
+
+    test("update should normalize non-bindable sqlite values", async () => {
+        const repository = new TestSqliteRepository(`/tmp/${randomUUID()}.db`);
+        repository.build();
+
+        const created = await repository.create({
+            title: "initial"
+        });
+
+        const bornAt = new Date("2025-06-07T08:09:10.000Z");
+
+        const updated = await repository.update(created._id, {
+            payload: {nested: ["x"]},
+            tags: ["updated"],
+            enabled: false,
+            bornAt,
+            optional: undefined
+        });
+
+        const raw = repository.findRawById(created._id);
+
+        assert.deepEqual(updated.payload, {nested: ["x"]});
+        assert.deepEqual(updated.tags, ["updated"]);
+        assert.equal(updated.enabled, false);
+        assert.equal(updated.bornAt, bornAt.toISOString());
+        assert.equal(updated.optional, null);
+        assert.equal(raw.payload, JSON.stringify({nested: ["x"]}));
+        assert.equal(raw.tags, JSON.stringify(["updated"]));
+        assert.equal(raw.enabled, 0);
+        assert.equal(raw.bornAt, bornAt.toISOString());
+        assert.equal(raw.optional, null);
+        assert.ok(typeof raw.updatedAt === "string");
+    });
+});