adminforth 1.2.95 → 1.2.97

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

@@ -23,10 +23,11 @@ import { ADMINFORTH_VERSION, listify } from './modules/utils.js';
 import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, } from './types/AdminForthConfig.js';
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
-import AdminForthRestAPI from './modules/restApi.js';
+import AdminForthRestAPI, { interpretResource } from './modules/restApi.js';
 import ClickhouseConnector from './dataConnectors/clickhouse.js';
 // exports
 export * from './types/AdminForthConfig.js';
+export { interpretResource };
 export { AdminForthPlugin };
 class AdminForth {
     constructor(config) {
@@ -205,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/modules/restApi.js

@@ -10,6 +10,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { AdminForthFilterOperators, AdminForthDataTypes, AllowedActionsEnum, ActionCheckSource } from "../types/AdminForthConfig.js";
 import { ADMINFORTH_VERSION, listify } from './utils.js';
 import AdminForthAuth from "../auth.js";
+export function interpretResource(adminUser, resource, meta, source) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        // if (process.env.HEAVY_DEBUG) {
+        //   console.log('🪲Interpreting resource', resource.resourceId, source, 'adminUser', adminUser);
+        // }
+        const allowedActions = {};
+        yield Promise.all(Object.entries(((_a = resource.options) === null || _a === void 0 ? void 0 : _a.allowedActions) || {}).map((_b) => __awaiter(this, [_b], void 0, function* ([key, value]) {
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🪲checking for allowed call', key, 'value:', value, 'typeof', typeof value);
+            }
+            // if callable then call
+            if (typeof value === 'function') {
+                allowedActions[key] = yield value({ adminUser, resource, meta, source });
+            }
+            else {
+                allowedActions[key] = value;
+            }
+        })));
+        return { allowedActions };
+    });
+}
 export default class AdminForthRestAPI {
     constructor(adminforth) {
         this.adminforth = adminforth;
@@ -159,12 +181,10 @@ export default class AdminForthRestAPI {
                 };
                 function processMenuItem(menuItem) {
                     return __awaiter(this, void 0, void 0, function* () {
-                        console.log('super hueta');
                         if (menuItem.badge) {
-                            console.log('hueta');
-                            // if (typeof menuItem.badge !== 'string') {
-                            menuItem.badge = yield menuItem.badge(adminUser);
-                            // }
+                            if (typeof menuItem.badge === 'function') {
+                                menuItem.badge = yield menuItem.badge(adminUser);
+                            }
                         }
                     });
                 }
@@ -185,12 +205,12 @@ export default class AdminForthRestAPI {
                                     continue;
                                 }
                             }
-                            processMenuItem(newChild);
+                            yield processMenuItem(newChild);
                             newChildren.push(newChild);
                         }
                         newMenuItem = Object.assign(Object.assign({}, newMenuItem), { children: newChildren });
                     }
-                    processMenuItem(newMenuItem);
+                    yield processMenuItem(newMenuItem);
                     newMenu.push(newMenuItem);
                 }
                 const announcementBadge = (_o = (_m = this.adminforth.config.customization).announcementBadge) === null || _o === void 0 ? void 0 : _o.call(_m, adminUser);
@@ -217,28 +237,6 @@ export default class AdminForthRestAPI {
                 };
             }),
         });
-        function interpretResource(adminUser, resource, meta, source) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                // if (process.env.HEAVY_DEBUG) {
-                //   console.log('🪲Interpreting resource', resource.resourceId, source, 'adminUser', adminUser);
-                // }
-                const allowedActions = {};
-                yield Promise.all(Object.entries(((_a = resource.options) === null || _a === void 0 ? void 0 : _a.allowedActions) || {}).map((_b) => __awaiter(this, [_b], void 0, function* ([key, value]) {
-                    if (process.env.HEAVY_DEBUG) {
-                        console.log('🪲checking for allowed call', key, 'value:', value, 'typeof', typeof value);
-                    }
-                    // if callable then call
-                    if (typeof value === 'function') {
-                        allowedActions[key] = yield value({ adminUser, resource, meta, source });
-                    }
-                    else {
-                        allowedActions[key] = value;
-                    }
-                })));
-                return { allowedActions };
-            });
-        }
         function checkAccess(action, allowedActions) {
             const allowed = allowedActions[action];
             if (allowed !== true) {