adminforth 1.3.26 → 1.3.28

package/auth.ts

@@ -1,6 +1,5 @@
 
 import jwt from 'jsonwebtoken';
-
 import crypto from 'crypto';
 import AdminForth from './index.js';
 

package/dataConnectors/baseConnector.ts

@@ -67,7 +67,6 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       offset: 0,
       getTotals: false
     });
-    process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
 
     return existingRecord.data.length > 0;
   }
@@ -90,14 +89,11 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       }
       recordWithOriginalValues[col.name] = this.setFieldValue(col, filledRecord[col.name]);
     }
-
     
     let error: string | null = null;
     await Promise.all(
       resource.dataSourceColumns.map(async (col) => {
-
         if (col.isUnique && !col.virtual && !error) {
-
           const exists = await this.checkUnique(resource, col, recordWithOriginalValues[col.name]);
           if (exists) {
             error = `Record with ${col.name} ${recordWithOriginalValues[col.name]} already exists`;
@@ -105,12 +101,12 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
         }
       })
     );
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
     if (error) {
+      process.env.HEAVY_DEBUG && console.log('🪲🆕 check unique error', error);
       return { error, ok: false };
     }
 
-    process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+    process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record', recordWithOriginalValues);
     await this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
 
     return {
@@ -119,10 +115,26 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     }
   }
 
-  updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void> {
+  updateRecordOriginalValues({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<void> {
     throw new Error('Method not implemented.');
   }
 
+  async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource; recordId: string; newValues: any; }): Promise<{ error?: string; ok: boolean; }> {
+    // transform value using setFieldValue and call updateRecordOriginalValues
+    const recordWithOriginalValues = {...newValues};
+
+    for (const field of Object.keys(newValues)) {
+      const col = resource.dataSourceColumns.find((col) => col.name == field);
+      recordWithOriginalValues[col.name] = this.setFieldValue(col, newValues[col.name]);
+    }
+
+    process.env.HEAVY_DEBUG && console.log(`🪲✏️ updating record id:${recordId}, values: ${JSON.stringify(recordWithOriginalValues)}`);
+
+    await this.updateRecordOriginalValues({ resource, recordId, newValues: recordWithOriginalValues });
+
+    return { ok: true };
+  }
+
   deleteRecord({ resource, recordId }: { resource: AdminForthResource; recordId: string; }): Promise<boolean> {
     throw new Error('Method not implemented.');
   }

package/dataConnectors/clickhouse.ts

@@ -303,11 +303,10 @@ class ClickhouseConnector extends AdminForthBaseConnector implements IAdminForth
       });
     }
 
-    async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
+    async updateRecordOriginalValues({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
       const columnsWithPlaceholders = Object.keys(newValues).map((col) => {
         return `${col} = {${col}:${resource.dataSourceColumns.find((c) => c.name == col)._underlineType}}`
       });
-      const values = [...Object.values(newValues), recordId];
 
       await this.client.command(
         { 

package/dataConnectors/mongo.ts

@@ -182,7 +182,7 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         await collection.insertOne(newRecord);
     }
 
-    async updateRecord({ resource, recordId, newValues }) {
+    async updateRecordOriginalValues({ resource, recordId, newValues }) {
         const collection = this.db.db().collection(resource.table);
         await collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });
     }

package/dataConnectors/postgres.ts

@@ -287,7 +287,7 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         await this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
     }
 
-    async updateRecord({ resource, recordId,  newValues }) {
+    async updateRecordOriginalValues({ resource, recordId,  newValues }) {
         const values = [...Object.values(newValues), recordId];
         const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');
         await this.db.query(`UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE "${this.getPrimaryKey(resource)}" = $${values.length}`, values);

package/dataConnectors/sqlite.ts

@@ -181,13 +181,12 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
 
       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];
 
       if (process.env.HEAVY_DEBUG) {
-        console.log('🪲 SQLITE Query', q, 'params:', d);
+        console.log('🪲📜 SQLITE Q', q, 'params:', d);
       }
       const rows = await stmt.all(d);
 
@@ -230,13 +229,14 @@ class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthData
       await q.run(values);
     }
 
-    async updateRecord({ resource, recordId, newValues }: { resource: AdminForthResource, recordId: any, newValues: any }) {
+    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);
     }
 

package/dist/dataConnectors/baseConnector.js

@@ -61,7 +61,6 @@ export default class AdminForthBaseConnector {
                 offset: 0,
                 getTotals: false
             });
-            process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 existingRecord|||', existingRecord);
             return existingRecord.data.length > 0;
         });
     }
@@ -90,11 +89,11 @@ export default class AdminForthBaseConnector {
                     }
                 }
             })));
-            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 error', error);
             if (error) {
+                process.env.HEAVY_DEBUG && console.log('🪲🆕 check unique error', error);
                 return { error, ok: false };
             }
-            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record', recordWithOriginalValues);
+            process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record', recordWithOriginalValues);
             yield this.createRecordOriginalValues({ resource, record: recordWithOriginalValues });
             return {
                 ok: true,
@@ -102,9 +101,22 @@ export default class AdminForthBaseConnector {
             };
         });
     }
-    updateRecord({ resource, recordId, newValues }) {
+    updateRecordOriginalValues({ resource, recordId, newValues }) {
         throw new Error('Method not implemented.');
     }
+    updateRecord(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
+            // transform value using setFieldValue and call updateRecordOriginalValues
+            const recordWithOriginalValues = Object.assign({}, newValues);
+            for (const field of Object.keys(newValues)) {
+                const col = resource.dataSourceColumns.find((col) => col.name == field);
+                recordWithOriginalValues[col.name] = this.setFieldValue(col, newValues[col.name]);
+            }
+            process.env.HEAVY_DEBUG && console.log(`🪲✏️ updating record id:${recordId}, values: ${JSON.stringify(recordWithOriginalValues)}`);
+            yield this.updateRecordOriginalValues({ resource, recordId, newValues: recordWithOriginalValues });
+            return { ok: true };
+        });
+    }
     deleteRecord({ resource, recordId }) {
         throw new Error('Method not implemented.');
     }

package/dist/dataConnectors/clickhouse.js

@@ -285,12 +285,11 @@ class ClickhouseConnector extends AdminForthBaseConnector {
             });
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const columnsWithPlaceholders = Object.keys(newValues).map((col) => {
                 return `${col} = {${col}:${resource.dataSourceColumns.find((c) => c.name == col)._underlineType}}`;
             });
-            const values = [...Object.values(newValues), recordId];
             yield this.client.command({
                 query: `ALTER TABLE ${this.dbName}.${resource.table} UPDATE ${columnsWithPlaceholders.join(', ')} WHERE ${this.getPrimaryKey(resource)} = {recordId:${resource.dataSourceColumns.find((c) => c.primaryKey)._underlineType}}`,
                 query_params: Object.assign(Object.assign({}, newValues), { recordId }),

package/dist/dataConnectors/mongo.js

@@ -171,7 +171,7 @@ class MongoConnector extends AdminForthBaseConnector {
             yield collection.insertOne(newRecord);
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const collection = this.db.db().collection(resource.table);
             yield collection.updateOne({ [this.getPrimaryKey(resource)]: recordId }, { $set: newValues });

package/dist/dataConnectors/postgres.js

@@ -283,7 +283,7 @@ class PostgresConnector extends AdminForthBaseConnector {
             yield this.db.query(`INSERT INTO ${tableName} (${columns.join(', ')}) VALUES (${placeholders})`, values);
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_a) {
         return __awaiter(this, arguments, void 0, function* ({ resource, recordId, newValues }) {
             const values = [...Object.values(newValues), recordId];
             const columnsWithPlaceholders = Object.keys(newValues).map((col, i) => `"${col}" = $${i + 1}`).join(', ');

package/dist/dataConnectors/sqlite.js

@@ -196,12 +196,11 @@ class SQLiteConnector extends AdminForthBaseConnector {
             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];
             if (process.env.HEAVY_DEBUG) {
-                console.log('🪲 SQLITE Query', q, 'params:', d);
+                console.log('🪲📜 SQLITE Q', q, 'params:', d);
             }
             const rows = yield stmt.all(d);
             return rows.map((row) => {
@@ -246,11 +245,12 @@ class SQLiteConnector extends AdminForthBaseConnector {
             yield q.run(values);
         });
     }
-    updateRecord(_a) {
+    updateRecordOriginalValues(_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)} = ?`);
+            process.env.HEAVY_DEBUG && console.log('🪲 SQLITE Query', `UPDATE ${resource.table} SET ${columnsWithPlaceholders} WHERE ${this.getPrimaryKey(resource)} = ?`, 'params:', values);
             yield q.run(values);
         });
     }

package/dist/index.js

@@ -20,7 +20,7 @@ import SQLiteConnector from './dataConnectors/sqlite.js';
 import CodeInjector from './modules/codeInjector.js';
 import ExpressServer from './servers/express.js';
 import { ADMINFORTH_VERSION, listify, suggestIfTypo } from './modules/utils.js';
-import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, } from './types/AdminForthConfig.js';
+import { AdminForthFilterOperators, AdminForthDataTypes, } from './types/AdminForthConfig.js';
 import AdminForthPlugin from './basePlugin.js';
 import ConfigValidator from './modules/configValidator.js';
 import AdminForthRestAPI, { interpretResource } from './modules/restApi.js';
@@ -157,23 +157,15 @@ class AdminForth {
     }
     createResourceRecord(_b) {
         return __awaiter(this, arguments, void 0, function* ({ resource, record, adminUser }) {
-            var _c, _d, _e, _f, _g;
-            for (const column of resource.columns) {
-                // TODO: assuming specifity for AdminForthResourcePages.create better to move it to api for this button
-                if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) &&
-                    record[column.name] === undefined &&
-                    column.showIn.includes(AdminForthResourcePages.create)) {
-                    return { error: `Column '${column.name}' is required`, ok: false };
-                }
-            }
+            var _c, _d, _e, _f;
             // execute hook if needed
-            for (const hook of listify((_e = (_d = resource.hooks) === null || _d === void 0 ? void 0 : _d.create) === null || _e === void 0 ? void 0 : _e.beforeSave)) {
+            for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c.create) === null || _d === void 0 ? void 0 : _d.beforeSave)) {
                 const resp = yield 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, ok: false };
+                    return { error: resp.error };
                 }
             }
             // remove virtual columns from record
@@ -183,15 +175,15 @@ class AdminForth {
                 }
             }
             const connector = this.connectors[resource.dataSource];
-            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
-            const { ok, error, createdRecord } = yield connector.createRecord({ resource, record, adminUser });
-            if (!ok) {
-                return { ok, error };
+            process.env.HEAVY_DEBUG && console.log('🪲🆕 creating record createResourceRecord', record);
+            const { error, createdRecord } = yield 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((_g = (_f = resource.hooks) === null || _f === void 0 ? void 0 : _f.create) === null || _g === void 0 ? void 0 : _g.afterSave)) {
-                console.log('Hook afterSave', hook);
+            for (const hook of listify((_f = (_e = resource.hooks) === null || _e === void 0 ? void 0 : _e.create) === null || _f === void 0 ? void 0 : _f.afterSave)) {
+                process.env.HEAVY_DEBUG && console.log('🪲 Hook afterSave', hook);
                 const resp = yield hook({
                     recordId: primaryKey,
                     resource,
@@ -202,10 +194,100 @@ class AdminForth {
                     throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
                 }
                 if (resp.error) {
-                    return { error: resp.error, ok: false };
+                    return { error: resp.error };
+                }
+            }
+            return { error, createdRecord };
+        });
+    }
+    /**
+     * record is partial record with only changed fields
+     */
+    updateResourceRecord(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, record, oldRecord, adminUser }) {
+            var _c, _d, _e, _f;
+            // execute hook if needed
+            for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c.edit) === null || _d === void 0 ? void 0 : _d.beforeSave)) {
+                const resp = yield 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) {
+                yield connector.updateRecord({ resource, recordId, newValues });
+            }
+            // execute hook if needed
+            for (const hook of listify((_f = (_e = resource.hooks) === null || _e === void 0 ? void 0 : _e.edit) === null || _f === void 0 ? void 0 : _f.afterSave)) {
+                const resp = yield 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' } `);
+                }
+                return { error: resp.error };
+            }
+        });
+    }
+    deleteResourceRecord(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, recordId, adminUser, record }) {
+            var _c, _d, _e, _f;
+            // execute hook if needed
+            for (const hook of listify((_d = (_c = resource.hooks) === null || _c === void 0 ? void 0 : _c.delete) === null || _d === void 0 ? void 0 : _d.beforeSave)) {
+                const resp = yield 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];
+            yield connector.deleteRecord({ resource, recordId });
+            // execute hook if needed
+            for (const hook of listify((_f = (_e = resource.hooks) === null || _e === void 0 ? void 0 : _e.delete) === null || _f === void 0 ? void 0 : _f.afterSave)) {
+                const resp = yield 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 { ok, error, createdRecord };
         });
     }
     resource(resourceId) {
@@ -234,6 +316,16 @@ AdminForth.Types = AdminForthDataTypes;
 AdminForth.Utils = {
     generatePasswordHash: (password) => __awaiter(void 0, void 0, void 0, function* () {
         return yield 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'
+        },
+    }
 };
 export default AdminForth;

package/dist/modules/codeInjector.js

@@ -217,13 +217,13 @@ class CodeInjector {
                         dereference: true, // needed to dereference types
                     });
                     if (process.env.HEAVY_DEBUG) {
-                        console.log('🪲 await fsExtra.copy copy single file', src, dest);
+                        console.log('🪲⚙️ fsExtra.copy copy single file', src, dest);
                     }
                 })));
             }
             else {
                 if (process.env.HEAVY_DEBUG) {
-                    console.log(`🪲 await fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, -> ${CodeInjector.SPA_TMP_PATH}`);
+                    console.log(`🪲⚙️ fsExtra.copy from ${path.join(ADMIN_FORTH_ABSOLUTE_PATH, 'spa')}, -> ${CodeInjector.SPA_TMP_PATH}`);
                 }
                 // try to rm SPA_TMP_PATH/src/types directory 
                 try {
@@ -237,7 +237,7 @@ class CodeInjector {
                     filter: (src) => {
                         const filterPasses = !src.includes('/adminforth/spa/node_modules') && !src.includes('/adminforth/spa/dist');
                         if (process.env.HEAVY_DEBUG && !filterPasses) {
-                            console.log('🪲 await fsExtra.copy filtered out', src);
+                            console.log('🪲⚙️ fsExtra.copy filtered out', src);
                         }
                         return filterPasses;
                     },
@@ -261,7 +261,7 @@ class CodeInjector {
                 for (const [src, dest] of Object.entries(this.srcFoldersToSync)) {
                     const to = path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom', dest);
                     if (process.env.HEAVY_DEBUG) {
-                        console.log(`🪲 await fsExtra.copy from ${src}, ${to}`);
+                        console.log(`🪲⚙️ fsExtra.copy from ${src}, ${to}`);
                     }
                     yield fsExtra.copy(src, to, {
                         recursive: true,
@@ -465,7 +465,7 @@ class CodeInjector {
             });
             yield collectDirectories(spaPath);
             if (process.env.HEAVY_DEBUG) {
-                console.log('🔎 Watching for changes in:', directories.join(','));
+                console.log('🪲🔎 Watch for:', directories.join(','));
             }
             const watcher = filewatcher();
             directories.forEach((dir) => {
@@ -514,11 +514,11 @@ class CodeInjector {
             yield collectDirectories(customComponentsDir);
             const watcher = filewatcher();
             files.forEach((file) => {
-                process.env.HEAVY_DEBUG && console.log(`🔎 Watching for changes in file ${file}`);
+                process.env.HEAVY_DEBUG && console.log(`🪲🔎 Watch for file ${file}`);
                 watcher.add(file);
             });
             if (process.env.HEAVY_DEBUG) {
-                console.log('🔎 Watching for changes in:', directories.join(','));
+                console.log('🪲🔎 Watch for:', directories.join(','));
             }
             watcher.on('change', (fileOrDir) => __awaiter(this, void 0, void 0, function* () {
                 // copy one file
@@ -568,7 +568,7 @@ class CodeInjector {
             }
             else {
                 const command = 'run dev';
-                console.log(`⚙️ spawn: npm ${command}...`);
+                console.log(`🪲⚙️ spawn: npm ${command}...`);
                 const nodeBinary = process.execPath;
                 const npmPath = path.join(path.dirname(nodeBinary), 'npm');
                 const env = Object.assign({ VITE_ADMINFORTH_PUBLIC_PATH: this.adminforth.config.baseUrl, FORCE_COLOR: '1' }, process.env);