adminforth 1.1.91 → 1.1.93

package/dataConnectors/baseConnector.ts

@@ -1,7 +1,7 @@
-import { AdminForthResource, AdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn } from "../types/AdminForthConfig.js";
+import { AdminForthResource, IAdminForthDataSourceConnectorBase, AdminForthSortDirections, AdminForthFilterOperators, AdminForthResourceColumn } from "../types/AdminForthConfig.js";
 
 
-export default class AdminForthBaseConnector implements AdminForthDataSourceConnectorBase {
+export default class AdminForthBaseConnector implements IAdminForthDataSourceConnectorBase {
   getPrimaryKey(resource: AdminForthResource): string {
     for (const col of resource.dataSourceColumns) {
         if (col.primaryKey) {

package/dataConnectors/mongo.ts

@@ -1,8 +1,8 @@
 import dayjs from 'dayjs';
 import { MongoClient } from 'mongodb';
-import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, AdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
 
-class MongoConnector implements AdminForthDataSourceConnector {
+class MongoConnector implements IAdminForthDataSourceConnector {
     db: MongoClient
 
     constructor({ url }: { url: string }) {

package/dataConnectors/postgres.ts

@@ -1,11 +1,11 @@
 import dayjs from 'dayjs';
 import pkg from 'pg';
-import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, AdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
+import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, IAdminForthDataSourceConnector } from '../types/AdminForthConfig.js';
 import AdminForthBaseConnector from './baseConnector.js';
 const { Client } = pkg;
 
 
-class PostgresConnector extends AdminForthBaseConnector implements AdminForthDataSourceConnector {
+class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDataSourceConnector {
 
     db: any;
 

package/dataConnectors/sqlite.ts

@@ -1,9 +1,9 @@
 import betterSqlite3 from 'better-sqlite3';
-import { AdminForthDataTypes, AdminForthFilterOperators, AdminForthSortDirections, AdminForthDataSourceConnector, AdminForthResource, AdminForthResourceColumn } from '../types/AdminForthConfig.js';
+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 AdminForthDataSourceConnector {
+class SQLiteConnector extends AdminForthBaseConnector implements IAdminForthDataSourceConnector {
 
     db: any;
 

package/dist/plugins/TwoFactorsAuthPlugin/index.js

@@ -7,9 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import AdminForthPlugin from "../base.js";
+import AdminForthPlugin from "adminforth/plugins/base.js";
 import twofactor from 'node-2fa';
-import AdminForthAuth from "../../auth.js";
 export default class TwoFactorsAuthPlugin extends AdminForthPlugin {
     constructor(options) {
         super(options, import.meta.url);
@@ -18,7 +17,7 @@ export default class TwoFactorsAuthPlugin extends AdminForthPlugin {
     modifyResourceConfig(adminforth, resourceConfig) {
         super.modifyResourceConfig(adminforth, resourceConfig);
         this.adminforth = adminforth;
-        this.adminForthAuth = new AdminForthAuth(adminforth);
+        this.adminForthAuth = adminforth.auth;
         const customPages = this.adminforth.config.customization.customPages;
         customPages.push({
             path: '/confirm2fa',

package/dist/spa/spa/src/components/Toast.vue

@@ -55,7 +55,7 @@ function closeToast() {
 onMounted(() => {
     if (props.toast.timeout === 'unlimited') return;
     else { 
-      setTimeout(() => {emit('close');}, props.toast.timeout  || 10000 );
+      setTimeout(() => {emit('close');}, (props.toast.timeout || 10) * 1e3 );
     }
 });
 

package/index.ts

@@ -9,8 +9,8 @@ import ExpressServer from './servers/express.js';
 import {v1 as uuid} from 'uuid';
 import fs from 'fs';
 import { ADMINFORTH_VERSION, listify } from './modules/utils.js';
-import { AdminForthConfig, AdminForthClass, AdminForthComponentDeclaration, AdminForthComponentDeclarationFull,
-  AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, GenericHttpServer, 
+import { AdminForthConfig, IAdminForth, AdminForthComponentDeclaration, AdminForthComponentDeclarationFull,
+  AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, IHttpServer, 
   BeforeSaveFunction,
   AfterSaveFunction,
   BeforeDataSourceRequestFunction,
@@ -19,7 +19,7 @@ import { AdminForthConfig, AdminForthClass, AdminForthComponentDeclaration, Admi
   AllowedActionsEnum,
   AllowedActions,
   ActionCheckSource,
-  AdminForthDataSourceConnector,
+  IAdminForthDataSourceConnector,
   BeforeLoginConfirmationFunction
 } from './types/AdminForthConfig.js';
 import path from 'path';
@@ -30,7 +30,7 @@ import AdminForthPlugin from './plugins/base.js';
 
 
 
-class AdminForth implements AdminForthClass {
+class AdminForth implements IAdminForth {
   static Types = AdminForthDataTypes;
 
   static Utils = {
@@ -649,7 +649,7 @@ class AdminForth implements AdminForthClass {
     }
 }
 
-  setupEndpoints(server: GenericHttpServer) {
+  setupEndpoints(server: IHttpServer) {
     server.endpoint({
       noAuth: true,
       method: 'POST',

package/modules/codeInjector.ts

@@ -9,7 +9,7 @@ import { promisify } from 'util';
 import AdminForth from '../index.js';
 import { ADMIN_FORTH_ABSOLUTE_PATH, getComponentNameFromPath, transformObject, deepMerge } from './utils.js';
 import { styles } from './styles.js'
-import { AdminForthComponentDeclaration, CodeInjectorType } from '../types/AdminForthConfig.js';
+import { AdminForthComponentDeclaration, ICodeInjector } from '../types/AdminForthConfig.js';
 import { StylesGenerator } from './styleGenerator.js';
 
 
@@ -36,7 +36,7 @@ function notifyWatcherIssue(limit) {
   console.log('Run ulimit -n 10000 to increase the limit for open files.');
 }
 
-class CodeInjector implements CodeInjectorType {
+class CodeInjector implements ICodeInjector {
 
   allWatchers = [];
   adminforth: AdminForth;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "adminforth",
-  "version": "1.1.91",
+  "version": "1.1.93",
   "description": "OpenSource Vue3 powered forth-generation admin panel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",
-    "prepareDist": "cp -r spa dist/spa && find plugins -type f ! -name '*.ts' -exec cp --parents {} dist \\;",
+    "prepareDist": "cp -r spa dist/spa",
     "rollout": "tsc && npm run prepareDist && npm version patch  && npm publish && cd documentation && npm run build && npm run deploy",
     "docs": "typedoc"
   },

package/plugins/AuditLogPlugin/index.ts

@@ -1,6 +1,6 @@
 import AdminForth from "../../index.js";
 import { 
-  AdminForthResource, AdminForthClass, BeforeDataSourceRequestFunction,
+  AdminForthResource, IAdminForth, BeforeDataSourceRequestFunction,
   AllowedActionsEnum,
   BeforeSaveFunction,
   AdminUser,
@@ -17,7 +17,7 @@ import { PluginOptions } from "./types.js";
 export default class AuditLogPlugin extends AdminForthPlugin {
  
   options: PluginOptions;
-  adminforth: AdminForthClass;
+  adminforth: IAdminForth;
   auditLogResource: string;
 
   constructor(options: PluginOptions) {
@@ -77,7 +77,7 @@ export default class AuditLogPlugin extends AdminForthPlugin {
     return {ok: true};
   }
 
-  modifyResourceConfig(adminforth: AdminForthClass, resourceConfig: AdminForthResource) {
+  modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
     super.modifyResourceConfig(adminforth, resourceConfig);
     this.adminforth = adminforth;
     this.auditLogResource = resourceConfig.resourceId;

package/plugins/ForeignInlineListPlugin/index.ts

@@ -1,4 +1,4 @@
-import { AdminForthResource, AdminForthResourcePages, AdminForthClass, GenericHttpServer } from "../../types/AdminForthConfig.js";
+import { AdminForthResource, AdminForthResourcePages, IAdminForth, IHttpServer } from "../../types/AdminForthConfig.js";
 import AdminForthPlugin from "../base.js";
 import { PluginOptions } from "./types.js";
 
@@ -6,14 +6,14 @@ import { PluginOptions } from "./types.js";
 export default class ForeignInlineListPlugin extends AdminForthPlugin {
   foreignResource: AdminForthResource;
   options: PluginOptions;
-  adminforth: AdminForthClass;
+  adminforth: IAdminForth;
 
   constructor(options: PluginOptions) {
     super(options, import.meta.url);
     this.options = options;
   }
 
-  setupEndpoints(server: GenericHttpServer) {
+  setupEndpoints(server: IHttpServer) {
     server.endpoint({
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/get_resource`,
@@ -34,7 +34,7 @@ export default class ForeignInlineListPlugin extends AdminForthPlugin {
 
   }
 
-  modifyResourceConfig(adminforth: AdminForthClass, resourceConfig: AdminForthResource) {
+  modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
     super.modifyResourceConfig(adminforth, resourceConfig);
     this.adminforth = adminforth;
 

package/plugins/S3UploadPlugin/custom/s3uploader.vue

@@ -103,11 +103,9 @@ const onFileChange = async (e) => {
     }
     reader.readAsDataURL(file);
   }
-  setInterval(() => {
-    progress.value += 1;
-  }, 20);
+  
 
-  await callAdminForthApi({
+  const { url, previewUrl, s3Path } = await callAdminForthApi({
       path: `/plugin/${props.meta.pluginInstanceId}/get_s3_upload_url`,
       method: 'POST',
       body: {
@@ -117,6 +115,28 @@ const onFileChange = async (e) => {
         originalExtension: extension,
       },
   });
+
+  console.log('S3 upload URL:', url);
+
+  const formData = new FormData();
+  for (const key in s3Path.fields) {
+    formData.append(key, s3Path.fields[key]);
+  }
+  formData.append('file', file);
+  // upload as multipart request and update upload progress
+  const response = await fetch(url, {
+    method: 'POST',
+    body: formData,
+    headers: {
+      'Content-Type': 'multipart/form-data',
+    },
+    onUploadProgress: (progressEvent) => {
+      progress.value = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+    }
+  });
+  const data = await response.json();
+  console.log('S3 upload response:', data);
+
 }
 
 

package/plugins/S3UploadPlugin/index.ts

@@ -1,19 +1,19 @@
 
-import { AdminForthClass, GenericHttpServer } from "../../types/AdminForthConfig.js";
+import { IAdminForth, IHttpServer } from "../../types/AdminForthConfig.js";
 import AdminForthPlugin from "../base.js";
 import { PluginOptions } from './types.js';
 import AWS from 'aws-sdk';
 
 export default class S3UploadPlugin extends AdminForthPlugin {
   options: PluginOptions;
-  adminforth: AdminForthClass;
+  adminforth: IAdminForth;
 
   constructor(options: PluginOptions) {
     super(options, import.meta.url);
     this.options = options;
   }
 
-  modifyResourceConfig(adminforth: AdminForthClass, resourceConfig: any) {
+  modifyResourceConfig(adminforth: IAdminForth, resourceConfig: any) {
     super.modifyResourceConfig(adminforth, resourceConfig);
     // after column to store the path of the uploaded file, add new VirtualColumn,
     // show only in edit and create views
@@ -63,7 +63,7 @@ export default class S3UploadPlugin extends AdminForthPlugin {
     }
   }
 
-  setupEndpoints(server: GenericHttpServer) {
+  setupEndpoints(server: IHttpServer) {
     server.endpoint({
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/get_s3_upload_url`,

package/plugins/S3UploadPlugin/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "s3uploadplugin",
+  "name": "@adminforth/s3upload",
   "version": "1.0.0",
   "description": "",
   "main": "index.js",

package/plugins/TwoFactorsAuthPlugin/dist/auth.js

@@ -0,0 +1,108 @@
+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 jwt from 'jsonwebtoken';
+import crypto from 'crypto';
+// Function to generate a password hash using PBKDF2
+function calcPasswordHash(password, salt, iterations = 100000, keyLength = 64, digest = 'sha512') {
+    return new Promise((resolve, reject) => {
+        crypto.pbkdf2(password, salt, iterations, keyLength, digest, (err, derivedKey) => {
+            if (err)
+                reject(err);
+            resolve(derivedKey.toString('hex'));
+        });
+    });
+}
+// Function to generate a random salt
+function generateSalt(length = 16) {
+    return crypto.randomBytes(length).toString('hex');
+}
+class AdminForthAuth {
+    constructor(adminforth) {
+        this.adminforth = adminforth;
+    }
+    removeAuthCookie(response) {
+        response.setHeader('Set-Cookie', `adminforth_jwt=; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict; Expires=Thu, 01 Jan 1970 00:00:00 GMT`);
+    }
+    setAuthCookie({ response, username, pk }) {
+        const token = this.issueJWT({ username, pk, }, 'auth');
+        response.setHeader('Set-Cookie', `adminforth_jwt=${token}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict`);
+    }
+    removeCustomCookie({ response, name }) {
+        response.setHeader('Set-Cookie', `adminforth_test'='2'; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict`);
+    }
+    setCustomCookie({ response, payload }) {
+        const { name, value, expiry, httpOnly } = payload;
+        response.setHeader('Set-Cookie', `adminforth_${name}=${value}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict; Expires=${new Date(Date.now() + expiry).toUTCString()} `);
+    }
+    issueJWT(payload, type) {
+        // read ADMINFORH_SECRET from environment if not drop error
+        const secret = process.env.ADMINFORTH_SECRET;
+        if (!secret) {
+            throw new Error('ADMINFORTH_SECRET environment not set');
+        }
+        // issue JWT token
+        const expiresIn = process.env.ADMINFORTH_AUTH_EXPIRESIN || '24h';
+        return jwt.sign(Object.assign(Object.assign({}, payload), { t: type }), secret, { expiresIn });
+    }
+    verify(jwtToken, mustHaveType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // read ADMINFORH_SECRET from environment if not drop error
+            const secret = process.env.ADMINFORTH_SECRET;
+            if (!secret) {
+                throw new Error('ADMINFORTH_SECRET environment not set');
+            }
+            let decoded;
+            try {
+                // verify JWT token
+                decoded = jwt.verify(jwtToken, secret);
+            }
+            catch (err) {
+                if (err.name === 'TokenExpiredError') {
+                    console.error('Token expired:', err.message);
+                }
+                else if (err.name === 'JsonWebTokenError') {
+                    console.error('Token error:', err.message);
+                }
+                else {
+                    console.error('Failed to verify JWT token', err);
+                }
+                return null;
+            }
+            const { pk, t } = decoded;
+            if (t !== mustHaveType) {
+                console.error(`Invalid token type during verification: ${t}, must be ${mustHaveType}`);
+                return null;
+            }
+            if (pk === null) {
+                decoded.isRoot = true;
+            }
+            else {
+                const dbUser = yield this.adminforth.getUserByPk(pk);
+                decoded.dbUser = dbUser;
+            }
+            return decoded;
+        });
+    }
+    static generatePasswordHash(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = generateSalt();
+            const hashedPassword = yield calcPasswordHash(password, salt);
+            return `${salt}:${hashedPassword}`;
+        });
+    }
+    static verifyPassword(password, hashedPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [salt, hash] = hashedPassword.split(':');
+            const newHash = yield calcPasswordHash(password, salt);
+            return newHash === hash;
+        });
+    }
+}
+export default AdminForthAuth;

package/plugins/TwoFactorsAuthPlugin/dist/dataConnectors/baseConnector.js

@@ -0,0 +1,90 @@
+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 { AdminForthFilterOperators } from "../types/AdminForthConfig.js";
+export default class AdminForthBaseConnector {
+    getPrimaryKey(resource) {
+        for (const col of resource.dataSourceColumns) {
+            if (col.primaryKey) {
+                return col.name;
+            }
+        }
+    }
+    getRecordByPrimaryKeyWithOriginalTypes(resource, id) {
+        throw new Error('Method not implemented.');
+    }
+    getDataWithOriginalTypes({ resource, limit, offset, sort, filters }) {
+        throw new Error('Method not implemented.');
+    }
+    discoverFields(resource) {
+        throw new Error('Method not implemented.');
+    }
+    getFieldValue(field, value) {
+        throw new Error('Method not implemented.');
+    }
+    setFieldValue(field, value) {
+        throw new Error('Method not implemented.');
+    }
+    getMinMaxForColumnsWithOriginalTypes({ resource, columns }) {
+        throw new Error('Method not implemented.');
+    }
+    createRecord({ resource, record }) {
+        throw new Error('Method not implemented.');
+    }
+    updateRecord({ resource, recordId, newValues }) {
+        throw new Error('Method not implemented.');
+    }
+    deleteRecord({ resource, recordId }) {
+        throw new Error('Method not implemented.');
+    }
+    getData(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, limit, offset, sort, filters }) {
+            if (filters) {
+                filters.map((f) => {
+                    if (f.operator == AdminForthFilterOperators.IN || f.operator == AdminForthFilterOperators.NIN) {
+                        f.value = f.value.map((val) => this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), val));
+                    }
+                    else {
+                        f.value = this.setFieldValue(resource.dataSourceColumns.find((col) => col.name == f.field), f.value);
+                    }
+                });
+            }
+            const d = yield this.getDataWithOriginalTypes({ resource, limit, offset, sort, filters });
+            // call getFieldValue for each field
+            d.data.map((record) => {
+                for (const col of resource.dataSourceColumns) {
+                    record[col.name] = this.getFieldValue(col, record[col.name]);
+                }
+            });
+            return d;
+        });
+    }
+    getMinMaxForColumns(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, columns }) {
+            const mm = yield this.getMinMaxForColumnsWithOriginalTypes({ resource, columns });
+            const result = {};
+            for (const col of columns) {
+                result[col.name] = {
+                    min: this.getFieldValue(col, mm[col.name].min),
+                    max: this.getFieldValue(col, mm[col.name].max),
+                };
+            }
+            return result;
+        });
+    }
+    getRecordByPrimaryKey(resource, recordId) {
+        return this.getRecordByPrimaryKeyWithOriginalTypes(resource, recordId).then((record) => {
+            const newRecord = {};
+            for (const col of resource.dataSourceColumns) {
+                newRecord[col.name] = this.getFieldValue(col, record[col.name]);
+            }
+            return newRecord;
+        });
+    }
+}