@appsemble/cli 0.20.44 → 0.21.0

package/server/db/methods.js

@@ -0,0 +1,232 @@
+import { getDb } from './index.js';
+const defaults = {
+    AppId: 1,
+    $created: new Date(),
+    $updated: new Date(),
+    expires: null,
+};
+let appName = 'app';
+export function setAppName(name) {
+    appName = name;
+}
+const comparators = ['gt', 'gte', 'lt', 'lte', 'eq', 'ne'];
+const expressions = ['and', 'or'];
+function parseValue(value) {
+    const toNumber = Number(value);
+    if (!Number.isNaN(toNumber)) {
+        return toNumber;
+    }
+    const toDate = Date.parse(value);
+    if (!Number.isNaN(toDate)) {
+        return toDate;
+    }
+    if (value === 'false' || value === 'true') {
+        return Boolean(value);
+    }
+    return value;
+}
+function applyQuery(entity, key, query) {
+    if (query == null && entity[key] == null) {
+        return true;
+    }
+    if (query === undefined && entity[key] === undefined) {
+        return true;
+    }
+    const parsedEntityValue = parseValue(entity[key]);
+    if (typeof query === 'string') {
+        return parsedEntityValue === parseValue(query);
+    }
+    if (query.or && Array.isArray(query.or)) {
+        return query.or.some((subQuery) => applyQuery(entity, key, subQuery));
+    }
+    if (query.and && Array.isArray(query.and)) {
+        return query.and.every((subQuery) => applyQuery(entity, key, subQuery));
+    }
+    if (query.gt) {
+        return parsedEntityValue > parseValue(query.gt);
+    }
+    if (query.gte) {
+        return parsedEntityValue >= parseValue(query.gte);
+    }
+    if (query.lt) {
+        return parsedEntityValue < parseValue(query.lt);
+    }
+    if (query.lte) {
+        return parsedEntityValue <= parseValue(query.lte);
+    }
+    if (query.eq || query.eq === '') {
+        return parsedEntityValue === parseValue(query.eq);
+    }
+    if (query.ne || query.ne === '') {
+        return parsedEntityValue !== parseValue(query.ne);
+    }
+    return entity[key] === query;
+}
+function checkOr(entity, or) {
+    return or.some((subQuery) => {
+        if (subQuery.or) {
+            return checkOr(entity, subQuery.or);
+        }
+        if (subQuery.and) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            return checkAnd(entity, subQuery.and);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return checkEntity(entity, subQuery);
+    });
+}
+function checkAnd(entity, and) {
+    return and.every((subQuery) => {
+        if (subQuery.or) {
+            return checkOr(entity, subQuery.or);
+        }
+        if (subQuery.and) {
+            return checkAnd(entity, subQuery.and);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return checkEntity(entity, subQuery);
+    });
+}
+function checkEntity(entity, query) {
+    if (query.or && Array.isArray(query.or)) {
+        return checkOr(entity, query.or);
+    }
+    if (query.and && Array.isArray(query.and)) {
+        return checkAnd(entity, query.and);
+    }
+    return Object.entries(query).every(([key, value]) => applyQuery(entity, key, value));
+}
+function applyAttributes(entities, attributes) {
+    return entities.map((entity) => {
+        const result = {};
+        for (const attribute of attributes) {
+            if (entity[attribute] !== undefined) {
+                result[attribute] = entity[attribute];
+            }
+        }
+        return result;
+    });
+}
+function applyOrder(entities, order) {
+    for (const orderItem of order) {
+        entities.sort((a, b) => {
+            const [property, direction] = orderItem;
+            if (a[property] > b[property]) {
+                return direction === 'DESC' ? -1 : 1;
+            }
+            if (a[property] < b[property]) {
+                return direction === 'DESC' ? 1 : -1;
+            }
+            return 0;
+        });
+    }
+}
+function clearEntity(entity) {
+    const { AppId, type, ...cleanPayload } = entity;
+    if (!cleanPayload.expires) {
+        delete cleanPayload.expires;
+    }
+    return cleanPayload;
+}
+export const Methods = {
+    async create(values, modelDir = '/') {
+        const db = await getDb(appName);
+        const existing = await this.findAll({}, modelDir);
+        const payload = {
+            ...values,
+            id: existing.length + 1,
+            ...defaults,
+        };
+        await db.push(modelDir, payload, true);
+        return clearEntity(payload);
+    },
+    async bulkCreate(values, modelDir = '/', override = false) {
+        const db = await getDb(appName);
+        const existing = await this.findAll({}, modelDir);
+        const payload = values.map((value, index) => ({
+            ...value,
+            id: existing.length + index + 1,
+            ...defaults,
+        }));
+        await db.push(modelDir, payload, existing.length === 0 ? true : override);
+        return payload.map((instance) => clearEntity(instance));
+    },
+    async findById(id, modelDir = '/') {
+        try {
+            const db = await getDb(appName);
+            const entityIndex = await db.getIndex(modelDir, id);
+            return await db.getObject(`${modelDir}[${entityIndex}]`);
+        }
+        catch {
+            return null;
+        }
+    },
+    async findOne(query, modelDir = '/') {
+        try {
+            const db = await getDb(appName);
+            const entities = await db.getObject(modelDir);
+            let mapped = entities;
+            if (query.attributes && query.attributes.length > 0) {
+                mapped = applyAttributes(mapped, query.attributes);
+            }
+            let filtered = mapped;
+            if (query.where) {
+                filtered = filtered.filter((entity) => checkEntity(entity, query.where));
+            }
+            const sorted = filtered;
+            if (query.order) {
+                applyOrder(sorted, query.order);
+            }
+            return clearEntity(sorted[0]) || null;
+        }
+        catch {
+            return null;
+        }
+    },
+    async findAll(query = {}, modelDir = '/') {
+        try {
+            const db = await getDb(appName);
+            const entities = await db.getObject(modelDir);
+            const sliced = entities.slice(query.offset || 0, ((query.limit ? query.limit - 1 + (query.offset || 0) : 0) || entities.length) + 1);
+            let mapped = sliced;
+            if (query.attributes && query.attributes.length > 0) {
+                mapped = applyAttributes(mapped, query.attributes);
+            }
+            let filtered = mapped;
+            if (query.where) {
+                filtered = filtered.filter((entity) => checkEntity(entity, query.where));
+            }
+            const sorted = filtered;
+            if (query.order) {
+                applyOrder(sorted, query.order);
+            }
+            return sorted.map((instance) => clearEntity(instance));
+        }
+        catch {
+            return [];
+        }
+    },
+    async updateOne(id, values, modelDir = '/') {
+        try {
+            const db = await getDb(appName);
+            const entityIndex = await db.getIndex(modelDir, id);
+            const existing = await this.findById(id, modelDir);
+            await db.push(`${modelDir}[${entityIndex}]`, { ...existing, ...values }, true);
+            return this.findOne({ where: values }, modelDir);
+        }
+        catch {
+            return null;
+        }
+    },
+    async deleteOne(id, modelDir = '/') {
+        try {
+            const db = await getDb(appName);
+            const entityIndex = await db.getIndex(modelDir, id);
+            return await db.delete(`${modelDir}[${entityIndex}]`);
+        }
+        catch {
+            return null;
+        }
+    },
+};
+//# sourceMappingURL=methods.js.map

package/server/db/methods.test.js

@@ -0,0 +1,365 @@
+import { rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import globalCacheDir from 'global-cache-dir';
+import { Methods, setAppName } from './methods.js';
+const appName = 'testApp';
+setAppName(appName);
+const cacheDir = await globalCacheDir('appsemble');
+const dbDir = join(cacheDir, appName);
+const dbPath = join(dbDir, 'db.json');
+describe('methods', () => {
+    afterAll(async () => {
+        await rm(dbDir, { recursive: true, force: true });
+    });
+    describe('create', () => {
+        it('should create a new record and return it', async () => {
+            const result = await Methods.create({ name: 'testInstance' }, '/testModel');
+            expect(result).toHaveProperty('id');
+            expect(result).toHaveProperty('name', 'testInstance');
+        });
+        it('should add default values to the record', async () => {
+            const result = await Methods.create({ name: 'testInstance' }, '/testModel');
+            expect(result).toHaveProperty('$created');
+            expect(result).toHaveProperty('$updated');
+        });
+    });
+    describe('bulkCreate', () => {
+        it('should create multiple new records and return them', async () => {
+            const result = await Methods.bulkCreate([{ name: 'testInstance2' }, { name: 'testInstance3' }], '/testModel');
+            expect(result).toHaveLength(2);
+            expect(result[0]).toHaveProperty('id');
+            expect(result[0]).toHaveProperty('name', 'testInstance2');
+            expect(result[1]).toHaveProperty('id');
+            expect(result[1]).toHaveProperty('name', 'testInstance3');
+        });
+        it('should add default values to the records', async () => {
+            const result = await Methods.bulkCreate([{ name: 'testInstance2' }, { name: 'testInstance3' }], '/testModel');
+            expect(result[0]).toHaveProperty('$created');
+            expect(result[0]).toHaveProperty('$updated');
+            expect(result[1]).toHaveProperty('$created');
+            expect(result[1]).toHaveProperty('$updated');
+        });
+    });
+    describe('findById', () => {
+        it('should return a record by id', async () => {
+            await writeFile(dbPath, '{"testModel":[{"id":1,"name":"testInstance1"}]}');
+            const result = await Methods.findById(1, '/testModel');
+            expect(result).not.toBeNull();
+            expect(result).toHaveProperty('id', 1);
+        });
+        it('should return null if no record exists with the given id', async () => {
+            const result = await Methods.findById(999);
+            expect(result).toBeNull();
+        });
+    });
+    describe('findOne', () => {
+        it('should return a record that matches the query', async () => {
+            await writeFile(dbPath, '{"testModel":[{"id":1,"name":"testInstance1"}]}');
+            const result = await Methods.findOne({ where: { name: 'testInstance1' } }, '/testModel');
+            expect(result).not.toBeNull();
+            expect(result).toHaveProperty('name', 'testInstance1');
+        });
+        it('should return null if no record matches the query', async () => {
+            const result = await Methods.findOne({ where: { name: 'nonexistent' } }, '/testModel');
+            expect(result).toBeNull();
+        });
+    });
+    describe('findAll', () => {
+        it('should return an empty array when no entities exist', async () => {
+            const entities = await Methods.findAll({}, '/');
+            expect(entities).toStrictEqual([]);
+        });
+        it('should return all entities when no query is provided', async () => {
+            await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+            const entities = await Methods.findAll({}, '/person');
+            expect(entities).toStrictEqual([
+                { id: 1, name: 'Alice', age: 30 },
+                { id: 2, name: 'Bob', age: 25 },
+                { id: 3, name: 'Charlie', age: 35 },
+            ]);
+        });
+        it('should return all entities with only the specified attributes', async () => {
+            await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+            const entities = await Methods.findAll({ attributes: ['name', 'age'] }, '/person');
+            expect(entities).toStrictEqual([
+                { name: 'Alice', age: 30 },
+                { name: 'Bob', age: 25 },
+                { name: 'Charlie', age: 35 },
+            ]);
+        });
+        describe('should filter entities using where clauses', () => {
+            it('that contain and', async () => {
+                await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                const entities = await Methods.findAll({
+                    where: {
+                        and: [{ name: { eq: 'Alice' } }, { age: { gt: 20 } }],
+                    },
+                }, '/person');
+                expect(entities).toStrictEqual([{ id: 1, name: 'Alice', age: 30 }]);
+            });
+            it('that contain or', async () => {
+                await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                const entities = await Methods.findAll({
+                    where: {
+                        or: [{ name: { eq: 'Alice' } }, { age: { gt: 20 } }],
+                    },
+                }, '/person');
+                expect(entities).toStrictEqual([
+                    { id: 1, name: 'Alice', age: 30 },
+                    { id: 2, name: 'Alice', age: 20 },
+                    { id: 3, name: 'Bob', age: 25 },
+                    { id: 4, name: 'Charlie', age: 35 },
+                ]);
+            });
+            describe('that contain a comparison', () => {
+                describe('for greater than', () => {
+                    it('for numbers', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ age: { gt: 25 } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 1, name: 'Alice', age: 30 },
+                            { id: 4, name: 'Charlie', age: 35 },
+                        ]);
+                    });
+                    it('for dates', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","birthDate":"2023-07-05T13:18:26.870Z"}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ birthDate: { gt: '2023-07-04T13:18:26.870Z' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 1, name: 'Alice', birthDate: new Date('2023-07-05T13:18:26.870Z') },
+                        ]);
+                    });
+                });
+                describe('for greater than or equal', () => {
+                    it('for numbers', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                        const entitiesGte = await Methods.findAll({
+                            where: {
+                                or: [{ age: { gte: 25 } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGte).toStrictEqual([
+                            { id: 1, name: 'Alice', age: 30 },
+                            { id: 3, name: 'Bob', age: 25 },
+                            { id: 4, name: 'Charlie', age: 35 },
+                        ]);
+                    });
+                    it('for dates', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","birthDate":"2023-07-05T13:18:26.870Z"},{"id":2,"name":"Bob","birthDate":"2023-07-04T13:18:26.870Z"}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ birthDate: { gte: '2023-07-04T13:18:26.870Z' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 1, name: 'Alice', birthDate: new Date('2023-07-05T13:18:26.870Z') },
+                            { id: 2, name: 'Bob', birthDate: new Date('2023-07-04T13:18:26.870Z') },
+                        ]);
+                    });
+                });
+                describe('for less than', () => {
+                    it('for numbers', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                        const entitiesLt = await Methods.findAll({
+                            where: {
+                                or: [{ age: { lt: 25 } }],
+                            },
+                        }, '/person');
+                        expect(entitiesLt).toStrictEqual([{ id: 2, name: 'Alice', age: 20 }]);
+                    });
+                    it('for dates', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","birthDate":"2023-07-05T13:18:26.870Z"}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ birthDate: { lt: '2023-07-06T13:18:26.870Z' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 1, name: 'Alice', birthDate: new Date('2023-07-05T13:18:26.870Z') },
+                        ]);
+                    });
+                });
+                describe('for less than or equal', () => {
+                    it('for numbers', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                        const entitiesLt = await Methods.findAll({
+                            where: {
+                                or: [{ age: { lte: 25 } }],
+                            },
+                        }, '/person');
+                        expect(entitiesLt).toStrictEqual([
+                            { id: 2, name: 'Alice', age: 20 },
+                            { id: 3, name: 'Bob', age: 25 },
+                        ]);
+                    });
+                    it('for dates', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","birthDate":"2023-07-05T13:18:26.870Z"},{"id":2,"name":"Bob","birthDate":"2023-07-04T13:18:26.870Z"}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ birthDate: { lte: '2023-07-05T13:18:26.870Z' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 1, name: 'Alice', birthDate: new Date('2023-07-05T13:18:26.870Z') },
+                            { id: 2, name: 'Bob', birthDate: new Date('2023-07-04T13:18:26.870Z') },
+                        ]);
+                    });
+                });
+                describe('for equal', () => {
+                    it('for numbers', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                        const entitiesEq = await Methods.findAll({
+                            where: {
+                                or: [{ age: { eq: 25 } }],
+                            },
+                        }, '/person');
+                        expect(entitiesEq).toStrictEqual([{ id: 3, name: 'Bob', age: 25 }]);
+                    });
+                    it('for dates', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","birthDate":"2023-07-05T13:18:26.870Z"},{"id":2,"name":"Bob","birthDate":"2023-07-04T13:18:26.870Z"}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ birthDate: { eq: '2023-07-04T13:18:26.870Z' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 2, name: 'Bob', birthDate: new Date('2023-07-04T13:18:26.870Z') },
+                        ]);
+                    });
+                    it('for boolean values', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","married":false},{"id":2,"name":"Bob","married":true}]}');
+                        const entitiesEq = await Methods.findAll({
+                            where: {
+                                or: [{ married: { eq: true } }],
+                            },
+                        }, '/person');
+                        expect(entitiesEq).toStrictEqual([{ id: 2, name: 'Bob', married: true }]);
+                    });
+                    it('for strings', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]}');
+                        const entitiesEq = await Methods.findAll({
+                            where: {
+                                or: [{ name: { eq: 'Alice' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesEq).toStrictEqual([{ id: 1, name: 'Alice' }]);
+                    });
+                });
+                describe('for not equal', () => {
+                    it('for numbers', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Alice","age":20},{"id":3,"name":"Bob","age":25},{"id":4,"name":"Charlie","age":35}]}');
+                        const entitiesNe = await Methods.findAll({
+                            where: {
+                                or: [{ age: { ne: 25 } }],
+                            },
+                        }, '/person');
+                        expect(entitiesNe).toStrictEqual([
+                            { id: 1, name: 'Alice', age: 30 },
+                            { id: 2, name: 'Alice', age: 20 },
+                            { id: 4, name: 'Charlie', age: 35 },
+                        ]);
+                    });
+                    it('for dates', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","birthDate":"2023-07-05T13:18:26.870Z"},{"id":2,"name":"Bob","birthDate":"2023-07-04T13:18:26.870Z"}]}');
+                        const entitiesGt = await Methods.findAll({
+                            where: {
+                                or: [{ birthDate: { ne: '2023-07-04T13:18:26.870Z' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesGt).toStrictEqual([
+                            { id: 1, name: 'Alice', birthDate: new Date('2023-07-05T13:18:26.870Z') },
+                        ]);
+                    });
+                    it('for boolean values', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","married":false},{"id":2,"name":"Bob","married":true}]}');
+                        const entitiesEq = await Methods.findAll({
+                            where: {
+                                or: [{ married: { ne: true } }],
+                            },
+                        }, '/person');
+                        expect(entitiesEq).toStrictEqual([{ id: 1, name: 'Alice', married: false }]);
+                    });
+                    it('for strings', async () => {
+                        await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]}');
+                        const entitiesEq = await Methods.findAll({
+                            where: {
+                                or: [{ name: { ne: 'Alice' } }],
+                            },
+                        }, '/person');
+                        expect(entitiesEq).toStrictEqual([{ id: 2, name: 'Bob' }]);
+                    });
+                });
+            });
+        });
+        describe('should sort entities using order clauses', () => {
+            it('in ascending order', async () => {
+                await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+                const entities = await Methods.findAll({
+                    order: [['age', 'ASC']],
+                }, '/person');
+                expect(entities).toStrictEqual([
+                    { id: 2, name: 'Bob', age: 25 },
+                    { id: 1, name: 'Alice', age: 30 },
+                    { id: 3, name: 'Charlie', age: 35 },
+                ]);
+            });
+            it('in descending order', async () => {
+                await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+                const entities = await Methods.findAll({
+                    order: [['age', 'DESC']],
+                }, '/person');
+                expect(entities).toStrictEqual([
+                    { id: 3, name: 'Charlie', age: 35 },
+                    { id: 1, name: 'Alice', age: 30 },
+                    { id: 2, name: 'Bob', age: 25 },
+                ]);
+            });
+        });
+        it('limits the number of entities returned using the limit option', async () => {
+            await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+            const entities = await Methods.findAll({ limit: 2 }, '/person');
+            expect(entities).toStrictEqual([
+                { id: 1, name: 'Alice', age: 30 },
+                { id: 2, name: 'Bob', age: 25 },
+            ]);
+        });
+        it('skips the specified number of entities using the offset option', async () => {
+            await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+            const entities = await Methods.findAll({ offset: 1 }, '/person');
+            expect(entities).toStrictEqual([
+                { id: 2, name: 'Bob', age: 25 },
+                { id: 3, name: 'Charlie', age: 35 },
+            ]);
+        });
+    });
+    describe('updateOne', () => {
+        it('should update an existing record', async () => {
+            await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+            const result = await Methods.updateOne(1, { name: 'Jane' }, '/person');
+            expect(result).toStrictEqual({
+                id: 1,
+                name: 'Jane',
+                age: 30,
+            });
+        });
+    });
+    describe('deleteOne', () => {
+        it('should delete an entity', async () => {
+            await writeFile(dbPath, '{"person":[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25},{"id":3,"name":"Charlie","age":35}]}');
+            await Methods.deleteOne(1, '/person');
+            const entities = await Methods.findAll({}, '/person');
+            expect(entities).toStrictEqual([
+                { id: 2, name: 'Bob', age: 25 },
+                { id: 3, name: 'Charlie', age: 35 },
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=methods.test.js.map

package/server/models/Resource.d.ts

@@ -0,0 +1,14 @@
+import { type FindOptions } from '@appsemble/node-utils';
+export declare class Resource {
+    id: number;
+    $clonable: boolean;
+    $created: string;
+    $updated: string;
+    [key: string]: unknown;
+    static create(values: Record<string, unknown>, type: string): Promise<Resource | null>;
+    static bulkCreate(values: Record<string, unknown>[], type: string, override?: boolean): Promise<Resource[] | []>;
+    static findById(id: number | string, type: string): Promise<Resource | null>;
+    static findAll(query: FindOptions, type: string): Promise<Resource[] | []>;
+    static updateOne(id: number | string, values: Record<string, unknown>, type: string): Promise<Resource | null>;
+    static deleteOne(id: number | string, type: string): Promise<void>;
+}

package/server/models/Resource.js

@@ -0,0 +1,23 @@
+import { Methods } from '../db/methods.js';
+const dir = '/resources';
+export class Resource {
+    static create(values, type) {
+        return Methods.create({ ...values, type }, `${dir}/${type}[]`);
+    }
+    static bulkCreate(values, type, override = false) {
+        return Methods.bulkCreate(values.map((value) => ({ ...value, type })), `${dir}/${type}`, override);
+    }
+    static findById(id, type) {
+        return Methods.findById(id, `${dir}/${type}`);
+    }
+    static findAll(query, type) {
+        return Methods.findAll(query, `${dir}/${type}`);
+    }
+    static updateOne(id, values, type) {
+        return Methods.updateOne(id, values, `${dir}/${type}`);
+    }
+    static deleteOne(id, type) {
+        return Methods.deleteOne(id, `${dir}/${type}`);
+    }
+}
+//# sourceMappingURL=Resource.js.map

package/server/models/Theme.d.ts

@@ -0,0 +1,17 @@
+import { type FindOptions } from '@appsemble/node-utils';
+export declare class Theme {
+    bulmaVersion: string;
+    primaryColor: string;
+    linkColor: string;
+    successColor: string;
+    infoColor: string;
+    warningColor: string;
+    dangerColor: string;
+    themeColor: string;
+    splashColor: string;
+    fontFamily: string;
+    fontSource: string;
+    css: string;
+    static create(values: Record<string, unknown>): Promise<Theme | null>;
+    static findOne(query: FindOptions): Promise<Theme | null>;
+}

package/server/models/Theme.js

@@ -0,0 +1,11 @@
+import { Methods } from '../db/methods.js';
+const dir = '/themes';
+export class Theme {
+    static create(values) {
+        return Methods.create(values, dir);
+    }
+    static findOne(query) {
+        return Methods.findOne(query, dir);
+    }
+}
+//# sourceMappingURL=Theme.js.map