adminforth 1.2.25 → 1.2.26

package/dataConnectors/clickhouse.ts

@@ -0,0 +1,298 @@
+import betterSqlite3 from 'better-sqlite3';
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector, AdminForthResource, AdminForthResourceColumn } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
+import dayjs from 'dayjs';
+import { createClient } from '@clickhouse/client' // or '@clickhouse/client-web'
+
+
+
+class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForthDataSourceConnector {
+
+    client: any;
+    dbName: string;
+
+    /**
+     * url: http[s]://[username:password@]hostname:port[/database][?param1=value1&param2=value2]
+     * @param param0 
+     */
+    constructor({ url }: { url: string }) {
+      super();
+      this.dbName = new URL(url).pathname.replace('/', '');
+      // create connection here
+      this.client = createClient({ 
+        url: url.replace('clickhouse://', 'http://'),
+      });
+    }
+
+    async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
+        const tableName = resource.table;
+        const q = await this.client.query({
+          query: `SELECT * FROM system.columns WHERE table = '${tableName}' and database = '${this.dbName}'`,
+          format: 'JSONEachRow',
+        });
+        const rows = await q.json();
+
+        const fieldTypes = {};
+        rows.forEach((row) => {
+          const field: any = {};
+          const baseType = row.type;
+          if (baseType.startsWith('Int') || baseType.startsWith('UInt')) {
+            field.type = AdminForthDataTypes.INTEGER;
+          } else if (baseType === 'FixedString' || baseType === 'String') {
+            field.type = AdminForthDataTypes.STRING;
+            // TODO
+            // const length = baseType.match(/\d+/g);
+            // field.maxLength = length ? parseInt(length[0]) : null;
+          } else if (baseType == 'UUID') {
+            field.type = AdminForthDataTypes.STRING;
+          } else if (baseType.startsWith('Decimal')) {
+            field.type = AdminForthDataTypes.DECIMAL;
+            // const [precision, scale] = baseType.match(/\d+/g);
+            // TODO
+            // field.precision = parseInt(precision);
+            // field.scale = parseInt(scale);
+          } else if (baseType.startsWith('Float')) {
+            field.type = AdminForthDataTypes.FLOAT;
+          } else if (baseType == 'DateTime64' || baseType == 'DateTime') {
+            field.type = AdminForthDataTypes.DATETIME;
+          } else if (baseType == 'Date' || baseType == 'Date64') {
+            field.type = AdminForthDataTypes.DATE;
+          } else if (baseType == 'Boolean') {
+            field.type = AdminForthDataTypes.BOOLEAN;
+            field._underlineType = 'boolean';
+          } else {
+            field.type = 'unknown'
+          }
+          field._underlineType = baseType;
+          field._baseTypeDebug = baseType;
+          field.required = row.notnull == 1;
+          field.primaryKey = row.pk == 1;
+          field.default = row.dflt_value;
+          fieldTypes[row.name] = field
+        });
+        return fieldTypes;
+    }
+
+    getFieldValue(field: AdminForthResourceColumn, value: any): any {
+      if (field.type == AdminForthDataTypes.DATETIME) {
+        if (!value) {
+          return null;
+        }
+        if (field._underlineType.startsWith('Int') || field._underlineType.startsWith('UInt')) {
+          return dayjs.unix(+value).toISOString();
+        } else if (field._underlineType.startsWith('DateTime') 
+            || field._underlineType.startsWith('String') 
+            || field._underlineType.startsWith('FixedString')) {
+          return dayjs(value).toISOString();
+        } else {
+          throw new Error(`AdminForth does not support row type: ${field._underlineType} for timestamps, use VARCHAR (with iso strings) or TIMESTAMP/INT (with unix timestamps). Issue in field "${field.name}"`);
+        }
+      } else if (field.type == AdminForthDataTypes.DATE) {
+        if (!value) {
+          return null;
+        }
+        return dayjs(value).toISOString().split('T')[0];
+      } else if (field.type == AdminForthDataTypes.BOOLEAN) {
+        return !!value;
+      } else if (field.type == AdminForthDataTypes.JSON) {
+        if (field._underlineType.startsWith('String') || field._underlineType.startsWith('FixedString')) {
+          return JSON.parse(value);
+        } else {
+          console.error(`AdminForth: JSON field is not a string but ${field._underlineType}, this is not supported yet`);
+        }
+      }
+      return value;
+    }
+
+    async getRecordByPrimaryKeyWithOriginalTypes(resource: AdminForthResource, key: any): Promise<any> {
+        const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+        const tableName = resource.table;
+        const stmt = await this.client.query({
+          query: `SELECT ${columns} FROM ${tableName} WHERE ${this.getPrimaryKey(resource)} = ?`,
+          format: 'JSONEachRow',
+          query_params: [key],
+        });
+        const row = await stmt.json();
+        if (!row.length) {
+          return null;
+        }
+        return row[0];
+    }
+
+    setFieldValue(field: AdminForthResourceColumn, value: any): any {
+      if (field.type == AdminForthDataTypes.DATETIME) {
+        if (!value) {
+          return null;
+        }
+        if (field._underlineType.startsWith('Int') || field._underlineType.startsWith('UInt')) {
+          // value is iso string now, convert to unix timestamp
+          return dayjs(value).unix();
+        } else if (field._underlineType.startsWith('DateTime') 
+          || field._underlineType.startsWith('String') 
+          || field._underlineType.startsWith('FixedString')) {
+          // value is iso string now, convert to unix timestamp
+          return dayjs(value).toISOString();
+        }
+      } else if (field.type == AdminForthDataTypes.BOOLEAN) {
+        return value ? 1 : 0;
+      } else if (field.type == AdminForthDataTypes.JSON) {
+        // check underline type is text or string
+        if (field._underlineType.startsWith('String') || field._underlineType.startsWith('FixedString')) {
+          return JSON.stringify(value);
+        } else {
+          console.error(`AdminForth: JSON field is not a string/text but ${field._underlineType}, this is not supported yet`);
+        }
+      }
+
+      return value;
+    }
+
+    OperatorsMap = {
+      [AdminForthFilterOperators.EQ]: '=',
+      [AdminForthFilterOperators.NE]: '!=',
+      [AdminForthFilterOperators.GT]: '>',
+      [AdminForthFilterOperators.LT]: '<',
+      [AdminForthFilterOperators.GTE]: '>=',
+      [AdminForthFilterOperators.LTE]: '<=',
+      [AdminForthFilterOperators.LIKE]: 'LIKE',
+      [AdminForthFilterOperators.ILIKE]: 'ILIKE',
+      [AdminForthFilterOperators.IN]: 'IN',
+      [AdminForthFilterOperators.NIN]: 'NOT IN',
+    };
+
+    SortDirectionsMap = {
+      [AdminForthSortDirections.asc]: 'ASC',
+      [AdminForthSortDirections.desc]: 'DESC',
+    };
+    
+
+    async getDataWithOriginalTypes({ 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 }> {
+      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+      const tableName = resource.table;
+
+      const where = filters.length ? `WHERE ${filters.map((f, i) => {
+        let placeholder = `{f${i}}`;
+        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}`).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 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 = {
+        ...params,
+        limit,
+        offset,
+      };
+      console.log('🪲 Clickhouse Query', q, 'params:', d);
+
+      const stmt = await this.client.query({
+        query: q,
+        format: 'JSONEachRow',
+        query_params: d,
+      });
+
+      if (process.env.HEAVY_DEBUG) {
+        console.log('🪲 Clickhouse Query', q, 'params:', d);
+      }
+      const rows = await stmt.json();
+
+
+      const countQ = await this.client.query({
+        query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
+        format: 'JSONEachRow',
+        query_params: d,
+      });
+      const total = (
+        await countQ.json()
+      )['COUNT(*)'];
+
+      return {
+        data: rows.map((row) => {
+          const newRow = {};
+          for (const [key, value] of Object.entries(row)) {
+            newRow[key] = value;
+          }
+          return newRow;
+        }),
+        total,
+      };
+    }
+
+    async getMinMaxForColumnsWithOriginalTypes({ resource, columns }: { resource: AdminForthResource, columns: AdminForthResourceColumn[] }): Promise<{ [key: string]: { min: any, max: any } }> {
+      const tableName = resource.table;
+      const result = {};
+      await Promise.all(columns.map(async (col) => {
+        // const stmt = await this.db.prepare(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
+        // const { min, max } = stmt.get();
+        // result[col.name] = {
+        //   min, max,
+        // };
+      }))
+      return result;
+    }
+
+    async createRecordOriginalValues({ resource, record }: { resource: AdminForthResource, record: any }) {
+      const tableName = resource.table;
+      const columns = Object.keys(record);
+      await this.client.insert({
+        table: tableName,
+        values: columns.map((colName) => {
+          return {[colName]: record[colName]};
+        }),
+        format: 'JSONEachRow',
+      })
+      
+    }
+
+    async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
+      const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
+      const values = [...Object.values(newValues), recordId];
+
+      // const q = this.db.prepare(
+      //     `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`
+      // )
+      // await q.run(values);
+    }
+
+    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }) {
+      // const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
+      // await q.run(recordId);
+    }
+
+    close() {
+      this.client.disconnect();
+    }
+}
+
+export default ClickhouseConnector;

package/dist/dataConnectors/clickhouse.js

@@ -0,0 +1,290 @@
+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());
+    });
+};
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections } from '../types/AdminForthConfig.js';
+import AdminForthBaseConnector from './baseConnector.js';
+import dayjs from 'dayjs';
+import { createClient } from '@clickhouse/client'; // or '@clickhouse/client-web'
+class ClickhouseConnector extends AdminForthBaseConnector {
+    /**
+     * url: http[s]://[username:password@]hostname:port[/database][?param1=value1&param2=value2]
+     * @param param0
+     */
+    constructor({ url }) {
+        super();
+        this.OperatorsMap = {
+            [AdminForthFilterOperators.EQ]: '=',
+            [AdminForthFilterOperators.NE]: '!=',
+            [AdminForthFilterOperators.GT]: '>',
+            [AdminForthFilterOperators.LT]: '<',
+            [AdminForthFilterOperators.GTE]: '>=',
+            [AdminForthFilterOperators.LTE]: '<=',
+            [AdminForthFilterOperators.LIKE]: 'LIKE',
+            [AdminForthFilterOperators.ILIKE]: 'ILIKE',
+            [AdminForthFilterOperators.IN]: 'IN',
+            [AdminForthFilterOperators.NIN]: 'NOT IN',
+        };
+        this.SortDirectionsMap = {
+            [AdminForthSortDirections.asc]: 'ASC',
+            [AdminForthSortDirections.desc]: 'DESC',
+        };
+        this.dbName = new URL(url).pathname.replace('/', '');
+        // create connection here
+        this.client = createClient({
+            url: url.replace('clickhouse://', 'http://'),
+        });
+    }
+    discoverFields(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableName = resource.table;
+            const q = yield this.client.query({
+                query: `SELECT * FROM system.columns WHERE table = '${tableName}' and database = '${this.dbName}'`,
+                format: 'JSONEachRow',
+            });
+            const rows = yield q.json();
+            const fieldTypes = {};
+            rows.forEach((row) => {
+                const field = {};
+                const baseType = row.type;
+                if (baseType.startsWith('Int') || baseType.startsWith('UInt')) {
+                    field.type = AdminForthDataTypes.INTEGER;
+                }
+                else if (baseType === 'FixedString' || baseType === 'String') {
+                    field.type = AdminForthDataTypes.STRING;
+                    // TODO
+                    // const length = baseType.match(/\d+/g);
+                    // field.maxLength = length ? parseInt(length[0]) : null;
+                }
+                else if (baseType == 'UUID') {
+                    field.type = AdminForthDataTypes.STRING;
+                }
+                else if (baseType.startsWith('Decimal')) {
+                    field.type = AdminForthDataTypes.DECIMAL;
+                    // const [precision, scale] = baseType.match(/\d+/g);
+                    // TODO
+                    // field.precision = parseInt(precision);
+                    // field.scale = parseInt(scale);
+                }
+                else if (baseType.startsWith('Float')) {
+                    field.type = AdminForthDataTypes.FLOAT;
+                }
+                else if (baseType == 'DateTime64' || baseType == 'DateTime') {
+                    field.type = AdminForthDataTypes.DATETIME;
+                }
+                else if (baseType == 'Date' || baseType == 'Date64') {
+                    field.type = AdminForthDataTypes.DATE;
+                }
+                else if (baseType == 'Boolean') {
+                    field.type = AdminForthDataTypes.BOOLEAN;
+                    field._underlineType = 'boolean';
+                }
+                else {
+                    field.type = 'unknown';
+                }
+                field._underlineType = baseType;
+                field._baseTypeDebug = baseType;
+                field.required = row.notnull == 1;
+                field.primaryKey = row.pk == 1;
+                field.default = row.dflt_value;
+                fieldTypes[row.name] = field;
+            });
+            return fieldTypes;
+        });
+    }
+    getFieldValue(field, value) {
+        if (field.type == AdminForthDataTypes.DATETIME) {
+            if (!value) {
+                return null;
+            }
+            if (field._underlineType.startsWith('Int') || field._underlineType.startsWith('UInt')) {
+                return dayjs.unix(+value).toISOString();
+            }
+            else if (field._underlineType.startsWith('DateTime')
+                || field._underlineType.startsWith('String')
+                || field._underlineType.startsWith('FixedString')) {
+                return dayjs(value).toISOString();
+            }
+            else {
+                throw new Error(`AdminForth does not support row type: ${field._underlineType} for timestamps, use VARCHAR (with iso strings) or TIMESTAMP/INT (with unix timestamps). Issue in field "${field.name}"`);
+            }
+        }
+        else if (field.type == AdminForthDataTypes.DATE) {
+            if (!value) {
+                return null;
+            }
+            return dayjs(value).toISOString().split('T')[0];
+        }
+        else if (field.type == AdminForthDataTypes.BOOLEAN) {
+            return !!value;
+        }
+        else if (field.type == AdminForthDataTypes.JSON) {
+            if (field._underlineType.startsWith('String') || field._underlineType.startsWith('FixedString')) {
+                return JSON.parse(value);
+            }
+            else {
+                console.error(`AdminForth: JSON field is not a string but ${field._underlineType}, this is not supported yet`);
+            }
+        }
+        return value;
+    }
+    getRecordByPrimaryKeyWithOriginalTypes(resource, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
+            const tableName = resource.table;
+            const stmt = yield this.client.query({
+                query: `SELECT ${columns} FROM ${tableName} WHERE ${this.getPrimaryKey(resource)} = ?`,
+                format: 'JSONEachRow',
+                query_params: [key],
+            });
+            const row = yield stmt.json();
+            if (!row.length) {
+                return null;
+            }
+            return row[0];
+        });
+    }
+    setFieldValue(field, value) {
+        if (field.type == AdminForthDataTypes.DATETIME) {
+            if (!value) {
+                return null;
+            }
+            if (field._underlineType.startsWith('Int') || field._underlineType.startsWith('UInt')) {
+                // value is iso string now, convert to unix timestamp
+                return dayjs(value).unix();
+            }
+            else if (field._underlineType.startsWith('DateTime')
+                || field._underlineType.startsWith('String')
+                || field._underlineType.startsWith('FixedString')) {
+                // value is iso string now, convert to unix timestamp
+                return dayjs(value).toISOString();
+            }
+        }
+        else if (field.type == AdminForthDataTypes.BOOLEAN) {
+            return value ? 1 : 0;
+        }
+        else if (field.type == AdminForthDataTypes.JSON) {
+            // check underline type is text or string
+            if (field._underlineType.startsWith('String') || field._underlineType.startsWith('FixedString')) {
+                return JSON.stringify(value);
+            }
+            else {
+                console.error(`AdminForth: JSON field is not a string/text but ${field._underlineType}, this is not supported yet`);
+            }
+        }
+        return value;
+    }
+    getDataWithOriginalTypes(_a) {
+        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 = `{f${i}}`;
+                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}`).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 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,
+                offset });
+            console.log('🪲 Clickhouse Query', q, 'params:', d);
+            const stmt = yield this.client.query({
+                query: q,
+                format: 'JSONEachRow',
+                query_params: d,
+            });
+            if (process.env.HEAVY_DEBUG) {
+                console.log('🪲 Clickhouse Query', q, 'params:', d);
+            }
+            const rows = yield stmt.json();
+            const countQ = yield this.client.query({
+                query: `SELECT COUNT(*) FROM ${tableName} ${where}`,
+                format: 'JSONEachRow',
+                query_params: d,
+            });
+            const total = (yield countQ.json())['COUNT(*)'];
+            return {
+                data: rows.map((row) => {
+                    const newRow = {};
+                    for (const [key, value] of Object.entries(row)) {
+                        newRow[key] = value;
+                    }
+                    return newRow;
+                }),
+                total,
+            };
+        });
+    }
+    getMinMaxForColumnsWithOriginalTypes(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
+            const tableName = resource.table;
+            const result = {};
+            yield Promise.all(columns.map((col) => __awaiter(this, void 0, void 0, function* () {
+                // const stmt = await this.db.prepare(`SELECT MIN(${col.name}) as min, MAX(${col.name}) as max FROM ${tableName}`);
+                // const { min, max } = stmt.get();
+                // result[col.name] = {
+                //   min, max,
+                // };
+            })));
+            return result;
+        });
+    }
+    createRecordOriginalValues(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, record }) {
+            const tableName = resource.table;
+            const columns = Object.keys(record);
+            yield this.client.insert({
+                table: tableName,
+                values: columns.map((colName) => {
+                    return { [colName]: record[colName] };
+                }),
+                format: 'JSONEachRow',
+            });
+        });
+    }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
+            const columnsWithPlaceholders = Object.keys(newValues).map((col) => `${col} = ?`);
+            const values = [...Object.values(newValues), recordId];
+            // const q = this.db.prepare(
+            //     `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`
+            // )
+            // await q.run(values);
+        });
+    }
+    deleteRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId }) {
+            // const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
+            // await q.run(recordId);
+        });
+    }
+    close() {
+        this.client.disconnect();
+    }
+}
+export default ClickhouseConnector;

package/dist/index.js

@@ -24,6 +24,7 @@ import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
 import AdminForthRestAPI from './modules/restApi.js';
+import ClickhouseConnector from './dataConnectors/clickhouse.js';
 // exports
 export * from './types/AdminForthConfig.js';
 export { AdminForthPlugin };
@@ -65,6 +66,7 @@ class AdminForth {
                 'sqlite': SQLiteConnector,
                 'postgres': PostgresConnector,
                 'mongodb': MongoConnector,
+                'clickhouse': ClickhouseConnector,
             };
             if (!this.config.databaseConnectors) {
                 this.config.databaseConnectors = Object.assign({}, this.connectorClasses);

package/dist/modules/restApi.js

@@ -201,7 +201,7 @@ export default class AdminForthRestAPI {
             return __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 if (process.env.HEAVY_DEBUG) {
-                    console.log('🪲Interpreting resource', resource.resourceId, source);
+                    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]) {
@@ -609,6 +609,7 @@ export default class AdminForthRestAPI {
             path: '/start_bulk_action',
             handler: (_11) => __awaiter(this, [_11], void 0, function* ({ body }) {
                 const { resourceId, actionId, recordIds, adminUser } = body;
+                process.env.HEAVY_DEBUG && console.log('🪲 starting bulk action', body);
                 const resource = this.adminforth.config.resources.find((res) => res.resourceId == resourceId);
                 if (!resource) {
                     return { error: `Resource '${resourceId}' not found` };

package/index.ts

@@ -19,6 +19,7 @@ import {
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
 import AdminForthRestAPI from './modules/restApi.js';
+import ClickhouseConnector from './dataConnectors/clickhouse.js';
 
 // exports
 export * from './types/AdminForthConfig.js'; 
@@ -92,6 +93,7 @@ class AdminForth implements IAdminForth {
       'sqlite': SQLiteConnector,
       'postgres': PostgresConnector,
       'mongodb': MongoConnector,
+      'clickhouse': ClickhouseConnector,
     };
     if (!this.config.databaseConnectors) {
       this.config.databaseConnectors = {...this.connectorClasses};

package/modules/restApi.ts

@@ -226,7 +226,7 @@ export default class AdminForthRestAPI {
 
     async function interpretResource(adminUser: AdminUser, resource: AdminForthResource, meta: any, source: ActionCheckSource): Promise<{allowedActions: AllowedActionsResolved}> {
       if (process.env.HEAVY_DEBUG) {
-        console.log('🪲Interpreting resource', resource.resourceId, source);
+        console.log('🪲Interpreting resource', resource.resourceId, source, 'adminUser', adminUser);
       }
       const allowedActions = {};
 
@@ -697,6 +697,7 @@ export default class AdminForthRestAPI {
         path: '/start_bulk_action',
         handler: async ({ body }) => {
             const { resourceId, actionId, recordIds, adminUser } = body;
+            process.env.HEAVY_DEBUG && console.log('🪲 starting bulk action', body);
             const resource = this.adminforth.config.resources.find((res) => res.resourceId == resourceId);
             if (!resource) {
                 return { error: `Resource '${resourceId}' not found` };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adminforth",
-  "version": "1.2.25",
+  "version": "1.2.26",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,6 +28,7 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
+    "@clickhouse/client": "^1.4.0",
     "@types/node": "^20.14.2",
     "typescript": "^5.4.5"
   }