adminforth 1.3.54-next.9 → 1.3.55-next.2

package/dataConnectors/sqlite.ts

@@ -1,254 +0,0 @@
-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';
-
-class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthDataSourceConnector {
-
-    db: any;
-
-    constructor({ url }: { url: string }) {
-      super();
-      // create connection here
-      this.db = betterSqlite3(url.replace('sqlite://', ''));
-    }
-
-    async discoverFields(resource: AdminForthResource): Promise<{[key: string]: AdminForthResourceColumn}> {
-        const tableName = resource.table;
-        const stmt = this.db.prepare(`PRAGMA table_info(${tableName})`);
-        const rows = await stmt.all();
-        const fieldTypes = {};
-        rows.forEach((row) => {
-          const field: any = {};
-          const baseType = row.type.toLowerCase();
-          if (baseType == 'int') {
-            field.type = AdminForthDataTypes.INTEGER;
-            field._underlineType = 'int';
-          } else if (baseType.includes('varchar(')) {
-            field.type = AdminForthDataTypes.STRING;
-            field._underlineType = 'varchar';
-            const length = baseType.match(/\d+/);
-            field.maxLength = length ? parseInt(length[0]) : null;
-          } else if (baseType == 'text') {
-            field.type = AdminForthDataTypes.TEXT;
-            field._underlineType = 'text';
-          } else if (baseType.includes('decimal(')) {
-            field.type = AdminForthDataTypes.DECIMAL;
-            field._underlineType = 'decimal';
-            const [precision, scale] = baseType.match(/\d+/g);
-            field.precision = parseInt(precision);
-            field.scale = parseInt(scale);
-          } else if (baseType == 'real') {
-            field.type = AdminForthDataTypes.FLOAT; //8-byte IEEE floating point number. It
-            field._underlineType = 'real';
-          } else if (baseType == 'timestamp') {
-            field.type = AdminForthDataTypes.DATETIME;
-            field._underlineType = 'timestamp';
-          } else if (baseType == 'boolean') {
-            field.type = AdminForthDataTypes.BOOLEAN;
-            field._underlineType = 'boolean';
-          } else if (baseType == 'datetime') {
-            field.type = AdminForthDataTypes.DATETIME;
-            field._underlineType = 'datetime';
-          } else {
-            field.type = 'unknown'
-          }
-          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 == 'timestamp' || field._underlineType == 'int') {
-          return dayjs.unix(+value).toISOString();
-        } else if (field._underlineType == 'varchar') {
-          return dayjs(value).toISOString();
-        } else if (field._underlineType == 'datetime') {
-          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 == 'text' || field._underlineType == 'varchar') {
-          return JSON.parse(value);
-        } else {
-          console.error(`AdminForth: JSON field is not a string/text but ${field._underlineType}, this is not supported yet`);
-        }
-      }
-
-      return value;
-    }
-
-    setFieldValue(field: AdminForthResourceColumn, value: any): any {
-      if (field.type == AdminForthDataTypes.DATETIME) {
-        if (!value) {
-          return null;
-        }
-        if (field._underlineType == 'timestamp' || field._underlineType == 'int') {
-          // value is iso string now, convert to unix timestamp
-          return dayjs(value).unix();
-        } else if (field._underlineType == 'varchar') {
-          // value is iso string now, convert to unix timestamp
-          return dayjs(value).toISOString();
-        } else {
-          return value;
-        }
-      } 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 == 'text' || field._underlineType == 'varchar') {
-          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',
-    };
-    
-    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;
-      }, []);
-    }
-
-    async getDataWithOriginalTypes({ resource, limit, offset, sort, filters }): Promise<any[]> {
-      const columns = resource.dataSourceColumns.map((col) => col.name).join(', ');
-      const tableName = resource.table;
-
-      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(', ')}` : '';
-      
-      const q = `SELECT ${columns} FROM ${tableName} ${where} ${orderBy} LIMIT ? OFFSET ?`;
-      const stmt = this.db.prepare(q);
-      const d = [...filterValues, limit, offset];
-
-      if (process.env.HEAVY_DEBUG) {
-        console.log('🪲📜 SQLITE Q', q, 'params:', d);
-      }
-      const rows = await stmt.all(d);
-
-      return rows.map((row) => {
-        const newRow = {};
-        for (const [key, value] of Object.entries(row)) {
-          newRow[key] = value;
-        }
-        return newRow;
-      })
-    }
-
-    async getCount({ 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(*)'];
-    }
-
-    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);
-      const placeholders = columns.map(() => '?').join(', ');
-      const values = columns.map((colName) => record[colName]);
-      const q = this.db.prepare(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`)
-      await q.run(values);
-    }
-
-    async updateRecordOriginalValues({ 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)} = ?`
-      )
-      process.env.HEAVY_DEBUG && console.log('🪲 SQLITE Query', `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`, 'params:', values);
-      await q.run(values);
-    }
-
-    async deleteRecord({ resource, recordId }: { resource: AdminForthResource, recordId: any }): Promise<boolean> {
-      const q = this.db.prepare(`DELETE FROM ${resource.table} WHERE ${this.getPrimaryKey(resource)} = ?`);
-      const res = await q.run(recordId);
-      return res.changes > 0;
-    }
-
-    close() {
-      this.db.close();
-    }
-}
-
-export default SQLiteConnector;

package/index.ts

@@ -1,428 +0,0 @@
-
-import AdminForthAuth from './auth.js';
-import MongoConnector from './dataConnectors/mongo.js';
-import PostgresConnector from './dataConnectors/postgres.js';
-import SQLiteConnector from './dataConnectors/sqlite.js';
-import CodeInjector from './modules/codeInjector.js';
-import ExpressServer from './servers/express.js';
-import { ADMINFORTH_VERSION, listify, suggestIfTypo, RateLimiter, getClinetIp } from './modules/utils.js';
-import { 
-  type AdminForthConfig, 
-  type IAdminForth, 
-  type IConfigValidator,
-  IOperationalResource,
-  AdminForthFilterOperators,
-  AdminForthDataTypes, IHttpServer, 
-  BeforeSaveFunction,
-  AfterSaveFunction,
-  AdminUser,
-  AdminForthResource,
-  IAdminForthDataSourceConnectorBase,
-} from './types/AdminForthConfig.js';
-import AdminForthPlugin from './basePlugin.js';
-import ConfigValidator from './modules/configValidator.js';
-import AdminForthRestAPI, { interpretResource } from './modules/restApi.js';
-import ClickhouseConnector from './dataConnectors/clickhouse.js';
-import OperationalResource from './modules/operationalResource.js';
-
-// exports
-export * from './types/AdminForthConfig.js'; 
-export { interpretResource };
-export { AdminForthPlugin };
-export { suggestIfTypo, RateLimiter, getClinetIp };
-
-
-class AdminForth implements IAdminForth {
-  static Types = AdminForthDataTypes;
-
-  static Utils = {
-    generatePasswordHash: async (password) => {
-      return await AdminForthAuth.generatePasswordHash(password);
-    },
-
-    PASSWORD_VALIDATORS: {
-      UP_LOW_NUM_SPECIAL: {
-        regExp: '^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#\\$%\\^&\\*\\(\\)\\-_=\\+\\[\\]\\{\\}\\|;:\',\\.<>\\/\\?]).+$',
-        message: 'Password must include at least one uppercase letter, one lowercase letter, one number, and one special character'
-      },
-      UP_LOW_NUM: {
-        regExp: '^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).+$',
-        message: 'Password must include at least one uppercase letter, one lowercase letter, and one number'
-      },
-    },
-    EMAIL_VALIDATOR: {
-      regExp: '^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}$',
-      message: 'Email is not valid, must be in format example@test.com',
-    }
-  }
-
-  #defaultConfig = {
-    deleteConfirmation: true,
-  }
-
-  config: AdminForthConfig;
-  express: ExpressServer;
-  auth: AdminForthAuth;
-  codeInjector: CodeInjector;
-  connectors: {
-    [dataSourceId: string]: IAdminForthDataSourceConnectorBase,
-  };
-  connectorClasses: any;
-  runningHotReload: boolean;
-  activatedPlugins: Array<AdminForthPlugin>;
-  configValidator: IConfigValidator;
-  restApi: AdminForthRestAPI;
-  operationalResources: {
-    [resourceId: string]: IOperationalResource,
-  }
-  baseUrlSlashed: string;
-
-  statuses: {
-    dbDiscover: 'running' | 'done',
-  }
-
-  constructor(config: AdminForthConfig) {
-    this.config = {...this.#defaultConfig,...config};
-    this.codeInjector = new CodeInjector(this);
-    this.configValidator = new ConfigValidator(this, this.config);
-    this.restApi = new AdminForthRestAPI(this);
-    this.activatedPlugins = [];
-    
-    this.configValidator.validateConfig();
-    this.activatePlugins();
-    this.configValidator.validateConfig();   // revalidate after plugins
-
-    this.express = new ExpressServer(this);
-    this.auth = new AdminForthAuth(this);
-    this.connectors = {};
-    this.statuses = {
-      dbDiscover: 'running',
-    };
-
-    console.log(`🚀 AdminForth v${ADMINFORTH_VERSION} starting up`)
-  }
-
-  activatePlugins() {
-    process.env.HEAVY_DEBUG && console.log('🔌🔌🔌 Activating plugins');
-    const allPluginInstances = [];
-    for (let resource of this.config.resources) {
-      for (let pluginInstance of resource.plugins || []) {
-        allPluginInstances.push({pi: pluginInstance, resource});
-      }
-    }
-    allPluginInstances.sort(({pi: a}, {pi: b}) => a.activationOrder - b.activationOrder);
-    allPluginInstances.forEach(
-      ({pi: pluginInstance, resource}) => {
-        pluginInstance.modifyResourceConfig(this, resource);
-        const plugin = this.activatedPlugins.find((p) => p.pluginInstanceId === pluginInstance.pluginInstanceId);
-        if (plugin) {
-          process.env.HEAVY_DEBUG && console.log(`Current plugin pluginInstance.pluginInstanceId ${pluginInstance.pluginInstanceId}`);
-          
-          throw new Error(`Attempt to activate Plugin ${pluginInstance.constructor.name} second time for same resource, but plugin does not support it. 
-            To support multiple plugin instance pre one resource, plugin should return unique string values for each installation from instanceUniqueRepresentation`);
-        }
-        this.activatedPlugins.push(pluginInstance);
-      }
-    );
-  }
-
-  getPluginsByClassName<T>(className: string): T[] {
-    const plugins = this.activatedPlugins.filter((plugin) => plugin.className === className);
-    return plugins as T[];
-  }
-
-  getPluginByClassName<T>(className: string): T {
-    const plugins = this.getPluginsByClassName(className);
-    if (plugins.length > 1) {
-      throw new Error(`Multiple plugins with className ${className} found. Use getPluginsByClassName instead`);
-    }
-    if (plugins.length === 0) {
-      const similar = suggestIfTypo(this.activatedPlugins.map((p) => p.className), className);
-      throw new Error(`Plugin with className ${className} not found. ${similar ? `Did you mean ${similar}?` : ''}`);
-    }
-    return plugins[0] as T;
-  }
-
-  async discoverDatabases() {
-    this.statuses.dbDiscover = 'running';
-    this.connectorClasses = {
-      'sqlite': SQLiteConnector,
-      'postgres': PostgresConnector,
-      'mongodb': MongoConnector,
-      'clickhouse': ClickhouseConnector,
-    };
-    if (!this.config.databaseConnectors) {
-      this.config.databaseConnectors = {...this.connectorClasses};
-    }
-    this.config.dataSources.forEach((ds) => {
-      const dbType = ds.url.split(':')[0];
-      if (!this.config.databaseConnectors[dbType]) {
-        throw new Error(`Database type '${dbType}' is not supported, consider using one of ${Object.keys(this.connectorClasses).join(', ')} or create your own data-source connector`);
-      }
-      this.connectors[ds.id] = new this.config.databaseConnectors[dbType]({url: ds.url});  
-    });
-
-    await Promise.all(this.config.resources.map(async (res) => {
-      if (!this.connectors[res.dataSource]) {
-        const similar = suggestIfTypo(Object.keys(this.connectors), res.dataSource);
-        throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}' ${similar 
-          ? `. Did you mean '${similar}'?` : 'Available dataSources: '+Object.keys(this.connectors).join(', ')}`
-        );
-      }
-      const fieldTypes = await this.connectors[res.dataSource].discoverFields(res);
-      if (fieldTypes !== null && !Object.keys(fieldTypes).length) {
-        throw new Error(`Table '${res.table}' (In resource '${res.resourceId}') has no fields or does not exist`);
-      }
-      if (fieldTypes === null) {
-        console.error(`⛔ DataSource ${res.dataSource} was not able to perform field discovery. It will not work properly`);
-        return;
-      }
-      if (!res.columns) {
-        res.columns = Object.keys(fieldTypes).map((name) => ({ name }));
-      }
-
-      res.columns.forEach((col, i) => {
-        if (!fieldTypes[col.name] && !col.virtual) {
-          const similar = suggestIfTypo(Object.keys(fieldTypes), col.name);
-          throw new Error(`Resource '${res.table}' has no column '${col.name}'. ${similar ? `Did you mean '${similar}'?` : ''}`);
-        }
-        // first find discovered values, but allow override
-        res.columns[i] = { ...fieldTypes[col.name], ...col };
-      });
-
-      this.configValidator.postProcessAfterDiscover(res);
-
-      // check if primaryKey column is present
-      if (!res.columns.some((col) => col.primaryKey)) {
-        throw new Error(`Resource '${res.table}' has no column defined or auto-discovered. Please set 'primaryKey: true' in a columns which has unique value for each record and index`);
-      }
-
-    }));
-
-    this.statuses.dbDiscover = 'done';
-
-    this.operationalResources = {};
-    this.config.resources.forEach((resource) => {
-      this.operationalResources[resource.resourceId] = new OperationalResource(this.connectors[resource.dataSource], resource);
-    });
-
-    // console.log('⚙️⚙️⚙️ Database discovery done', JSON.stringify(this.config.resources, null, 2));
-  }
-
-  async bundleNow({ hotReload=false }) {
-    await this.codeInjector.bundleNow({ hotReload });
-  }
-
-  async getUserByPk(pk: string) {
-    // if database discovery is not done, throw
-    if (this.statuses.dbDiscover !== 'done') {
-      if (this.statuses.dbDiscover === 'running') {
-        throw new Error('Database discovery is running. You can\'t use data API while database discovery is not finished.\n'+
-          'Consider moving your code to a place where it will be executed after database discovery is already done (after await admin.discoverDatabases())');
-      }
-      throw new Error('Database discovery is not yet started. You can\'t use data API before database discovery is done. \n'+
-        'Call admin.discoverDatabases() first and await it before using data API');
-    }
-
-    const resource = this.config.resources.find((res) => res.resourceId === this.config.auth.usersResourceId);
-    if (!resource) {
-      const similar = suggestIfTypo(this.config.resources.map((res) => res.resourceId), this.config.auth.usersResourceId);
-      throw new Error(`No resource with  ${this.config.auth.usersResourceId} found. ${similar ? 
-        `Did you mean '${similar}' in config.auth.usersResourceId?` : 'Please set correct resource in config.auth.usersResourceId'}`
-      );
-    }
-    const users = await this.connectors[resource.dataSource].getData({
-      resource,
-      filters: [
-        { field: resource.columns.find((col) => col.primaryKey).name, operator: AdminForthFilterOperators.EQ, value: pk },
-      ],
-      limit: 1,
-      offset: 0,
-      sort: [],
-    });
-    return users.data[0] || null;
-  }
-
-  async createResourceRecord(
-    { resource, record, adminUser }: 
-    { resource: AdminForthResource, record: any, adminUser: AdminUser }
-  ): Promise<{ error?: string, createdRecord?: any }> {
-
-    // execute hook if needed
-    for (const hook of listify(resource.hooks?.create?.beforeSave as BeforeSaveFunction[])) {
-      const resp = await hook({ recordId: undefined, resource, record, adminUser });
-      if (!resp || (!resp.ok && !resp.error)) {
-        throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
-      }
-
-      if (resp.error) {
-        return { error: resp.error };
-      }
-    }
-
-    // remove virtual columns from record
-    for (const column of resource.columns.filter((col) => col.virtual)) {
-      if (record[column.name]) {
-        delete record[column.name];
-      }
-    }
-    const connector = this.connectors[resource.dataSource];
-    process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record createResourceRecord', record);
-    const { error, createdRecord } = await connector.createRecord({ resource, record, adminUser });
-    if ( error ) {
-      return { error };
-    }
-    
-    const primaryKey = record[resource.columns.find((col) => col.primaryKey).name];
-
-    // execute hook if needed
-    for (const hook of listify(resource.hooks?.create?.afterSave as AfterSaveFunction[])) {
-      process.env.HEAVY_DEBUG && console.log('🪲 Hook afterSave', hook);
-      const resp = await hook({ 
-        recordId: primaryKey, 
-        resource, 
-        record: createdRecord, 
-        adminUser
-      });
-
-      if (!resp || (!resp.ok && !resp.error)) {
-        throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
-      }
-
-      if (resp.error) {
-        return { error: resp.error };
-      }
-    }
-
-    return { error, createdRecord };
-  }
-
-  /**
-   * record is partial record with only changed fields
-   */
-  async updateResourceRecord(
-    { resource, recordId, record, oldRecord, adminUser }:
-    { resource: AdminForthResource, recordId: any, record: any, oldRecord: any, adminUser: AdminUser }
-  ): Promise<{ error?: string }> {
-
-    // execute hook if needed
-    for (const hook of listify(resource.hooks?.edit?.beforeSave as BeforeSaveFunction[])) {
-      const resp = await hook({
-        recordId,
-        resource,
-        record,
-        oldRecord,
-        adminUser 
-      });
-      if (!resp || (!resp.ok && !resp.error)) {
-        throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
-      }
-      if (resp.error) {
-        return { error: resp.error };
-      }
-    }
-    const newValues = {};
-    const connector = this.connectors[resource.dataSource];
-
-    for (const recordField in record) {
-      if (record[recordField] !== oldRecord[recordField]) {
-        // leave only changed fields to reduce data transfer/modifications in db
-        const column = resource.columns.find((col) => col.name === recordField);
-        if (!column || !column.virtual) {
-          // exclude virtual columns
-          newValues[recordField] = record[recordField];
-        }
-      }
-    } 
-
-    if (Object.keys(newValues).length > 0) {
-      await connector.updateRecord({ resource, recordId, newValues });
-    }
-    
-    // execute hook if needed
-    for (const hook of listify(resource.hooks?.edit?.afterSave as AfterSaveFunction[])) {
-      const resp = await hook({ 
-        resource, 
-        record, 
-        adminUser, 
-        oldRecord,
-        recordId,
-      });
-      if (!resp || (!resp.ok && !resp.error)) {
-        throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
-      }
-      if (resp.error) {
-        return { error: resp.error };
-      }
-    }
-    
-    return { error: null };
-  }
-
-  async deleteResourceRecord(
-    { resource, recordId, adminUser, record }:
-    { resource: AdminForthResource, recordId: any, adminUser: AdminUser, record: any }
-  ): Promise<{ error?: string }> {
-    // execute hook if needed
-    for (const hook of listify(resource.hooks?.delete?.beforeSave as BeforeSaveFunction[])) {
-      const resp = await hook({ 
-        resource, 
-        record, 
-        adminUser,
-        recordId,
-      });
-      if (!resp || (!resp.ok && !resp.error)) {
-        throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
-      }
-
-      if (resp.error) {
-        return { error: resp.error };
-      }
-    }
-
-    const connector = this.connectors[resource.dataSource];
-    await connector.deleteRecord({ resource, recordId});
-
-    // execute hook if needed
-    for (const hook of listify(resource.hooks?.delete?.afterSave as BeforeSaveFunction[])) {
-      const resp = await hook({ 
-        resource, 
-        record, 
-        adminUser,
-        recordId,
-      });
-      if (!resp || (!resp.ok && !resp.error)) {
-        throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
-      }
-
-      if (resp.error) {
-        return { error: resp.error };
-      }
-    }
-
-    return { error: null };
-  }
-
-  resource(resourceId: string): IOperationalResource {
-    if (this.statuses.dbDiscover !== 'done') {
-      if (this.statuses.dbDiscover === 'running') {
-        throw new Error('Database discovery is running. You can\'t use data API while database discovery is not finished.\n'+
-          'Consider moving your code to a place where it will be executed after database discovery is already done (after await admin.discoverDatabases())');
-      } else {
-        throw new Error('Database discovery is not yet started. You can\'t use data API before database discovery is done. \n'+
-          'Call admin.discoverDatabases() first and await it before using data API');
-      }
-    }
-    if (!this.operationalResources[resourceId]) {
-      const closeName = suggestIfTypo(Object.keys(this.operationalResources), resourceId);
-      throw new Error(`Resource with id '${resourceId}' not found${closeName ? `. Did you mean '${closeName}'?` : ''}`);
-    }
-    return this.operationalResources[resourceId];
-  }
-
-  setupEndpoints(server: IHttpServer) {
-    this.restApi.registerEndpoints(server);
-  }
-}
-
-export default AdminForth;