adminforth 1.2.98 → 1.2.99

package/dist/dataConnectors/clickhouse.js

@@ -184,36 +184,43 @@ class ClickhouseConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClause(resource, filters) {
+        return filters.length ? `WHERE ${filters.map((f, i) => {
+            const column = resource.dataSourceColumns.find((col) => col.name == f.field);
+            let placeholder = `{f${i}:${column._underlineType}}`;
+            let field = f.field;
+            let operator = this.OperatorsMap[f.operator];
+            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                placeholder = `(${f.value.map((_, j) => `{p${i}_${j}:${column._underlineType}}`).join(', ')})`;
+            }
+            return `${field} ${operator} ${placeholder}`;
+        }).join(' AND ')}` : '';
+    }
+    whereParams(filters) {
+        const params = {};
+        filters.length ? filters.forEach((f, i) => {
+            // for arrays do set in map
+            const v = f.value;
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                params[`f${i}`] = `%${v}%`;
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                v.forEach((_, j) => {
+                    params[`p${i}_${j}`] = v[j];
+                });
+            }
+            else {
+                params[`f${i}`] = v;
+            }
+        }) : [];
+        return params;
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
             const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
             const tableName = resource.table;
-            const where = filters.length ? `WHERE ${filters.map((f, i) => {
-                const column = resource.dataSourceColumns.find((col) => col.name == f.field);
-                let placeholder = `{f${i}:${column._underlineType}}`;
-                let field = f.field;
-                let operator = this.OperatorsMap[f.operator];
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    placeholder = `(${f.value.map((_, j) => `{p${i}_${j}:${column._underlineType}}`).join(', ')})`;
-                }
-                return `${field} ${operator} ${placeholder}`;
-            }).join(' AND ')}` : '';
-            const params = {};
-            filters.length ? filters.forEach((f, i) => {
-                // for arrays do set in map
-                const v = f.value;
-                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-                    params[`f${i}`] = `%${v}%`;
-                }
-                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    v.forEach((_, j) => {
-                        params[`p${i}_${j}`] = v[j];
-                    });
-                }
-                else {
-                    params[`f${i}`] = v;
-                }
-            }) : [];
+            const where = this.whereClause(resource, filters);
+            const params = this.whereParams(filters);
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
             const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT {limit:Int} OFFSET {offset:Int}`;
             const d = Object.assign(Object.assign({}, params), { limit,
@@ -224,26 +231,27 @@ class ClickhouseConnector extends AdminForthBaseConnector {
                 query_params: d,
             });
             const rows = yield stmt.json();
-            let total = 0;
-            if (getTotals) {
-                const countQ = yield this.client.query({
-                    query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
-                    format: 'JSONEachRow',
-                    query_params: d,
-                });
-                const countResp = yield countQ.json();
-                total = countResp[0]['COUNT()'];
-            }
-            return {
-                data: rows.map((row) => {
-                    const newRow = {};
-                    for (const [key, value] of Object.entries(row)) {
-                        newRow[key] = value;
-                    }
-                    return newRow;
-                }),
-                total,
-            };
+            return rows.map((row) => {
+                const newRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    newRow[key] = value;
+                }
+                return newRow;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters, }) {
+            const tableName = resource.table;
+            const where = this.whereClause(resource, filters);
+            const d = this.whereParams(filters);
+            const countQ = yield this.client.query({
+                query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
+                format: 'JSONEachRow',
+                query_params: d,
+            });
+            const countResp = yield countQ.json();
+            return countResp[0]['COUNT()'];
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -291,10 +299,12 @@ class ClickhouseConnector extends AdminForthBaseConnector {
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
             const pkColumn = resource.dataSourceColumns.find((col) => col.primaryKey);
-            yield this.client.command({
+            const res = yield this.client.command({
                 query: `ALTER TABLE ${this.dbName}.${resource.table} DELETE WHERE ${pkColumn.name} = {recordId:${pkColumn._underlineType}}`,
                 query_params: { recordId },
             });
+            // todo test what is in res
+            return res;
         });
     }
     close() {

package/dist/dataConnectors/mongo.js

@@ -108,25 +108,41 @@ class MongoConnector extends AdminForthBaseConnector {
         }
         return value;
     }
-    getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
-            // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
-            const tableName = resource.table;
-            const collection = this.db.db().collection(tableName);
+    genQuery(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            const collection = this.db.db().collection(resource.table);
             const query = {};
             for (const filter of filters) {
                 query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
             }
-            let total = 0;
-            if (getTotals) {
-                total = yield collection.countDocuments(query);
-            }
+            return { collection, query };
+        });
+    }
+    getDataWithOriginalTypes(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            // const columns = resource.dataSourceColumns.filter(c=> !c.virtual).map((col) => col.name).join(', ');
+            const tableName = resource.table;
+            const collection = this.db.db().collection(tableName);
+            const query = this.genQuery({ resource, limit, offset, sort, filters });
+            const sortArray = sort.map((s) => {
+                return [s.field, this.SortDirectionsMap[s.direction]];
+            });
             const result = yield collection.find(query)
-                .sort(sort)
+                .sort(sortArray)
                 .skip(offset)
                 .limit(limit)
                 .toArray();
-            return { data: result, total };
+            return result;
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const collection = this.db.db().collection(resource.table);
+            const query = {};
+            for (const filter of filters) {
+                query[filter.field] = this.OperatorsMap[filter.operator](filter.value);
+            }
+            return yield collection.countDocuments(query);
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -166,7 +182,8 @@ class MongoConnector extends AdminForthBaseConnector {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
             const primaryKey = this.getPrimaryKey(resource);
             const collection = this.db.db().collection(resource.table);
-            yield collection.deleteOne({ [primaryKey]: recordId });
+            const res = yield collection.deleteOne({ [primaryKey]: recordId });
+            return res.deletedCount > 0;
         });
     }
     close() {

package/dist/dataConnectors/postgres.js

@@ -184,46 +184,54 @@ class PostgresConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClauseAndValues(resource, filters) {
+        let totalCounter = 1;
+        const where = filters.length ? `WHERE ${filters.map((f, i) => {
+            let placeholder = '$' + (totalCounter);
+            const fieldData = resource.dataSourceColumns.find((col) => col.name == f.field);
+            let field = f.field;
+            let operator = this.OperatorsMap[f.operator];
+            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                placeholder = `(${f.value.map((_, i) => `$${totalCounter + i}`).join(', ')})`;
+                totalCounter += f.value.length;
+            }
+            else {
+                totalCounter += 1;
+            }
+            if (fieldData._underlineType == 'uuid') {
+                field = `cast("${field}" as text)`;
+            }
+            else {
+                field = `"${field}"`;
+            }
+            return `${field} ${operator} ${placeholder}`;
+        }).join(' AND ')}` : '';
+        const filterValues = [];
+        filters.length ? filters.forEach((f) => {
+            // for arrays do set in map
+            let v = f.value;
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                filterValues.push(`%${v}%`);
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                filterValues.push(...v);
+            }
+            else {
+                filterValues.push(v);
+            }
+        }) : [];
+        return {
+            sql: where,
+            paramsCount: totalCounter,
+            values: filterValues,
+        };
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
             const columns = resource.dataSourceColumns.map((col) => `"${col.name}"`).join(', ');
             const tableName = resource.table;
-            let totalCounter = 1;
-            const where = filters.length ? `WHERE ${filters.map((f, i) => {
-                let placeholder = '$' + (totalCounter);
-                const fieldData = resource.dataSourceColumns.find((col) => col.name == f.field);
-                let field = f.field;
-                let operator = this.OperatorsMap[f.operator];
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    placeholder = `(${f.value.map((_, i) => `$${totalCounter + i}`).join(', ')})`;
-                    totalCounter += f.value.length;
-                }
-                else {
-                    totalCounter += 1;
-                }
-                if (fieldData._underlineType == 'uuid') {
-                    field = `cast("${field}" as text)`;
-                }
-                else {
-                    field = `"${field}"`;
-                }
-                return `${field} ${operator} ${placeholder}`;
-            }).join(' AND ')}` : '';
-            const filterValues = [];
-            filters.length ? filters.forEach((f) => {
-                // for arrays do set in map
-                let v = f.value;
-                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-                    filterValues.push(`%${v}%`);
-                }
-                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    filterValues.push(...v);
-                }
-                else {
-                    filterValues.push(v);
-                }
-            }) : [];
-            const limitOffset = `LIMIT $${totalCounter} OFFSET $${totalCounter + 1}`;
+            const { sql: where, paramsCount, values: filterValues } = this.whereClauseAndValues(resource, filters);
+            const limitOffset = `LIMIT $${paramsCount} OFFSET $${paramsCount + 1}`;
             const d = [...filterValues, limit, offset];
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `"${s.field}" ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
             const selectQuery = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} ${limitOffset}`;
@@ -232,20 +240,21 @@ class PostgresConnector extends AdminForthBaseConnector {
             }
             const stmt = yield this.db.query(selectQuery, d);
             const rows = stmt.rows;
-            let total = 0;
-            if (getTotals) {
-                total = (yield this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues)).rows[0].count;
-            }
-            return {
-                data: rows.map((row) => {
-                    const newRow = {};
-                    for (const [key, value] of Object.entries(row)) {
-                        newRow[key] = value;
-                    }
-                    return newRow;
-                }),
-                total,
-            };
+            return rows.map((row) => {
+                const newRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    newRow[key] = value;
+                }
+                return newRow;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const tableName = resource.table;
+            const { sql: where, values: filterValues } = this.whereClauseAndValues(resource, filters);
+            const stmt = yield this.db.query(`SELECT COUNT(*) FROM ${tableName} ${where}`, filterValues);
+            return stmt.rows[0].count;
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -283,7 +292,8 @@ class PostgresConnector extends AdminForthBaseConnector {
     }
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
-            yield this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+            const res = yield this.db.query(`DELETE FROM ${resource.table} WHERE "${this.getPrimaryKey(resource)}" = $1`, [recordId]);
+            return res.rowCount > 0;
         });
     }
     close() {

package/dist/dataConnectors/sqlite.js

@@ -149,39 +149,44 @@ class SQLiteConnector extends AdminForthBaseConnector {
         }
         return value;
     }
+    whereClause(filters) {
+        return filters.length ? `WHERE ${filters.map((f, i) => {
+            let placeholder = '?';
+            let field = f.field;
+            let operator = this.OperatorsMap[f.operator];
+            if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                placeholder = `(${f.value.map(() => '?').join(', ')})`;
+            }
+            else if (f.operator == AdminForthFilterOperators.ILIKE) {
+                placeholder = `LOWER(?)`;
+                field = `LOWER(${f.field})`;
+                operator = 'LIKE';
+            }
+            return `${field} ${operator} ${placeholder}`;
+        }).join(' AND ')}` : '';
+    }
+    whereParams(filters) {
+        return filters.reduce((acc, f) => {
+            if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
+                acc.push(`%${f.value}%`);
+            }
+            else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                acc.push(...f.value);
+            }
+            else {
+                acc.push(f.value);
+            }
+            return acc;
+        }, []);
+    }
     getDataWithOriginalTypes(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters, getTotals }) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
             const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
             const tableName = resource.table;
-            const where = filters.length ? `WHERE ${filters.map((f, i) => {
-                let placeholder = '?';
-                let field = f.field;
-                let operator = this.OperatorsMap[f.operator];
-                if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    placeholder = `(${f.value.map(() => '?').join(', ')})`;
-                }
-                else if (f.operator == AdminForthFilterOperators.ILIKE) {
-                    placeholder = `LOWER(?)`;
-                    field = `LOWER(${f.field})`;
-                    operator = 'LIKE';
-                }
-                return `${field} ${operator} ${placeholder}`;
-            }).join(' AND ')}` : '';
-            const filterValues = [];
-            filters.length ? filters.forEach((f) => {
-                // for arrays do set in map
-                const v = f.value;
-                if (f.operator == AdminForthFilterOperators.LIKE || f.operator == AdminForthFilterOperators.ILIKE) {
-                    filterValues.push(`%${v}%`);
-                }
-                else if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
-                    filterValues.push(...v);
-                }
-                else {
-                    filterValues.push(v);
-                }
-            }) : [];
+            const where = this.whereClause(filters);
+            const filterValues = this.whereParams(filters);
             const orderBy = sort.length ? `ORDER BY ${sort.map((s) => `${s.field} ${this.SortDirectionsMap[s.direction]}`).join(', ')}` : '';
+            console.log('🪲 SQLITE Query', `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`, 'params:', [...filterValues, limit, offset]);
             const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
             const stmt = this.db.prepare(q);
             const d = [...filterValues, limit, offset];
@@ -189,21 +194,22 @@ class SQLiteConnector extends AdminForthBaseConnector {
                 console.log('🪲 SQLITE Query', q, 'params:', d);
             }
             const rows = yield stmt.all(d);
-            let total = 0;
-            if (getTotals) {
-                const totalStmt = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`);
-                total = totalStmt.get([...filterValues])['COUNT(*)'];
-            }
-            return {
-                data: rows.map((row) => {
-                    const newRow = {};
-                    for (const [key, value] of Object.entries(row)) {
-                        newRow[key] = value;
-                    }
-                    return newRow;
-                }),
-                total,
-            };
+            return rows.map((row) => {
+                const newRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    newRow[key] = value;
+                }
+                return newRow;
+            });
+        });
+    }
+    getCount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, filters }) {
+            const tableName = resource.table;
+            const where = this.whereClause(filters);
+            const filterValues = this.whereParams(filters);
+            const totalStmt = this.db.prepare(`SELECT COUNT(*) FROM ${tableName} ${where}`);
+            return totalStmt.get([...filterValues])['COUNT(*)'];
         });
     }
     getMinMaxForColumnsWithOriginalTypes(_a) {
@@ -241,7 +247,8 @@ class SQLiteConnector extends AdminForthBaseConnector {
     deleteRecord(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
             const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
-            yield q.run(recordId);
+            const res = yield q.run(recordId);
+            return res.changes > 0;
         });
     }
     close() {

package/dist/index.js

@@ -206,6 +206,9 @@ class AdminForth {
             return { ok: true };
         });
     }
+    resource(resourceId) {
+        return this.config.resources.find((res) => res.resourceId === resourceId);
+    }
     setupEndpoints(server) {
         this.restApi.registerEndpoints(server);
     }

package/dist/modules/operationalResource.js

@@ -0,0 +1,88 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// export interface IOperationalResource {
+//   get: (filters: IAdminForthFilter | IAdminForthFilter[]) => Promise<any[]>;
+//   list: (filters: IAdminForthFilter | IAdminForthFilter[], limit: number, offset: number, sort: IAdminForthSort | IAdminForthSort[]) => Promise<any[]>;
+//   count: (filters: IAdminForthFilter | IAdminForthFilter[]) => Promise<number>;
+//   create: (record: any) => Promise<any>;
+//   update: (primaryKey: any, record: any) => Promise<any>;
+//   delete: (primaryKey: any) => Promise<boolean>;
+//   deleteMany: (primaryKeys: any[]) => Promise<boolean>;
+// }
+// async getData({ resource, limit, offset, sort, filters }: { 
+//   resource: AdminForthResource, 
+//   limit: number, 
+//   offset: number, 
+//   sort: { field: string, direction: AdminForthSortDirections }[], 
+//   filters: { field: string, operator: AdminForthFilterOperators, value: any }[]
+// }): Promise<{ data: any[], total: number }> {
+function filtersIfFilter(filter) {
+    return (typeof filter === 'object' ? [filter] : filter);
+}
+function sortsIfSort(sort) {
+    return (typeof sort === 'object' ? [sort] : sort);
+}
+export class OperationalResource {
+    constructor(dataConnector, resourceConfig) {
+        this.dataConnector = dataConnector;
+        this.resourceConfig = resourceConfig;
+    }
+    get(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.getData({
+                resource: this.resourceConfig,
+                filters: filtersIfFilter(filter),
+                limit: 1,
+                offset: 0,
+                sort: [],
+            })[0];
+        });
+    }
+    list(filter, limit, offset, sort) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.dataConnector.getData({
+                resource: this.resourceConfig,
+                filters: filtersIfFilter(filter),
+                limit,
+                offset,
+                sort: sortsIfSort(sort),
+                getTotals: false,
+            });
+            return data;
+        });
+    }
+    count(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.getCount({
+                resource: this.resourceConfig,
+                filters: filtersIfFilter(filter),
+            });
+        });
+    }
+    create(record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.createRecord({ resource: this.resourceConfig, record });
+        });
+    }
+    update(primaryKey, record) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.updateRecord({
+                resource: this.resourceConfig,
+                recordId: primaryKey,
+                newValues: record
+            });
+        });
+    }
+    delete(primaryKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataConnector.deleteRecord({ resource: this.resourceConfig, recordId: primaryKey });
+        });
+    }
+}

package/dist/types/AdminForthConfig.js

@@ -53,6 +53,43 @@ export var AdminForthResourcePages;
     AdminForthResourcePages["create"] = "create";
     AdminForthResourcePages["filter"] = "filter";
 })(AdminForthResourcePages || (AdminForthResourcePages = {}));
+export class Filters {
+    static EQ(field, value) {
+        return { field, operator: AdminForthFilterOperators.EQ, value };
+    }
+    static NEQ(field, value) {
+        return { field, operator: AdminForthFilterOperators.NE, value };
+    }
+    static GT(field, value) {
+        return { field, operator: AdminForthFilterOperators.GT, value };
+    }
+    static GTE(field, value) {
+        return { field, operator: AdminForthFilterOperators.GTE, value };
+    }
+    static LT(field, value) {
+        return { field, operator: AdminForthFilterOperators.LT, value };
+    }
+    static LTE(field, value) {
+        return { field, operator: AdminForthFilterOperators.LTE, value };
+    }
+    static IN(field, value) {
+        return { field, operator: AdminForthFilterOperators.IN, value };
+    }
+    static NOT_IN(field, value) {
+        return { field, operator: AdminForthFilterOperators.NIN, value };
+    }
+    static LIKE(field, value) {
+        return { field, operator: AdminForthFilterOperators.LIKE, value };
+    }
+}
+export class Sorts {
+    static ASC(field) {
+        return { field, direction: AdminForthSortDirections.asc };
+    }
+    static DESC(field) {
+        return { field, direction: AdminForthSortDirections.desc };
+    }
+}
 export var AllowedActionsEnum;
 (function (AllowedActionsEnum) {
     AllowedActionsEnum["show"] = "show";

package/index.ts

@@ -10,7 +10,9 @@ import {
   type AdminForthConfig, 
   type IAdminForth, 
   type IConfigValidator,
-  AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, IHttpServer, 
+  IOperationalResource,
+  AdminForthFilterOperators,
+  AdminForthDataTypes, AdminForthResourcePages, IHttpServer, 
   BeforeSaveFunction,
   AfterSaveFunction,
   AdminUser,
@@ -50,7 +52,9 @@ class AdminForth implements IAdminForth {
   activatedPlugins: Array<AdminForthPlugin>;
   configValidator: IConfigValidator;
   restApi: AdminForthRestAPI;
-
+  resourceInstances: {
+    [resourceId: string]: IOperationalResource,
+  }
   baseUrlSlashed: string;
 
   statuses: {
@@ -248,6 +252,10 @@ class AdminForth implements IAdminForth {
     return { ok: true };
   }
 
+  resource(resourceId: string) {
+    return this.config.resources.find((res) => res.resourceId === resourceId);
+  }
+
   setupEndpoints(server: IHttpServer) {
     this.restApi.registerEndpoints(server);
   }