Merge branch 'next' of https://github.com/devforth/adminforth

Author: NoOne7135

adminforth/auth.ts

@@ -82,14 +82,21 @@ class AdminForthAuth implements IAdminForthAuth {
     username: string, 
     pk: string | null
   }) {
+    console.log("in days", expireInDays);
     const expiresIn: string = expireInDays ? `${expireInDays}d` : (process.env.ADMINFORTH_AUTH_EXPIRESIN || '24h');
+    console.log("in string", expiresIn);
     // might be h,m,d in string
+
     const expiresInSec = parseTimeToSeconds(expiresIn);
 
+    console.log("expiresInSec", expiresInSec);
+
     const token = this.issueJWT({ username, pk}, 'auth', expiresIn);
+    console.log("token", token);
     const expiresCookieFormat = new Date(Date.now() + expiresInSec * 1000).toUTCString();
-    
+    console.log("expiresCookieFormat", expiresCookieFormat);
     const brandSlug = this.adminforth.config.customization.brandNameSlug;
+    console.log("brandSlug", brandSlug);
     response.setHeader('Set-Cookie', `adminforth_${brandSlug}_jwt=${token}; Path=${this.adminforth.config.baseUrl || '/'}; HttpOnly; SameSite=Strict; Expires=${expiresCookieFormat}`);
   }
 

adminforth/commands/createApp/templates/api.ts.hbs

@@ -0,0 +1,10 @@
+import { Express } from "express";
+import { IAdminForth } from "adminforth";
+
+export function initApi(app: Express, admin: IAdminForth) {
+  app.get(`${admin.config.baseUrl}/api/hello/`,
+    (req, res) => {
+      res.json({ message: "Hello from AdminForth API!" });
+    }
+  );
+}

adminforth/commands/createApp/templates/index.ts.hbs

@@ -4,7 +4,8 @@ import usersResource from "./resources/adminuser.js";
 import { fileURLToPath } from 'url';
 import path from 'path';
 import { Filters } from 'adminforth';
- 
+import { initApi } from './api.js';
+
 const ADMIN_BASE_URL = '';
 
 export const admin = new AdminForth({
@@ -69,6 +70,8 @@ if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
   const app = express();
   app.use(express.json());
 
+  initApi(app, admin);
+
   const port = 3500;
 
   admin.bundleNow({ hotReload: process.env.NODE_ENV === 'development' }).then(() => {

adminforth/commands/createApp/utils.js

@@ -235,6 +235,11 @@ async function writeTemplateFiles(dirname, cwd, options) {
       dest: 'index.ts',
       data: { appName },
     },
+    {
+      src: 'api.ts.hbs',
+      dest: 'api.ts',
+      data: {},
+    },
     {
       src: '.gitignore.hbs',
       dest: '.gitignore',

adminforth/commands/createCustomComponent/main.js

@@ -188,6 +188,9 @@ async function handleCrudPageInjectionCreation(config, resources) {
   const injectionPosition = await select({
     message: 'Where exactly do you want to inject the component?',
     choices: [
+      ...(crudType === 'create' || crudType === 'edit'
+        ? [{ name: '💾 Save button on create/edit page', value: 'saveButton' }, new Separator()]
+        : []),
       { name: '⬆️ Before Breadcrumbs', value: 'beforeBreadcrumbs' },
       { name: '➡️ Before Action Buttons', value: 'beforeActionButtons' },
       { name: '⬇️ After Breadcrumbs', value: 'afterBreadcrumbs' },
@@ -207,13 +210,15 @@ async function handleCrudPageInjectionCreation(config, resources) {
     },
   });
 
-  const isThin = await select({
-    message: 'Will this component be thin enough to fit on the same page with list (so list will still shrink)?',
-    choices: [
-      { name: 'Yes', value: true },
-      { name: 'No', value: false },
-    ],
-  });
+  const isThin = crudType === 'list'
+    ? await select({
+        message: 'Will this component be thin enough to fit on the same page with list (so list will still shrink)?',
+        choices: [
+          { name: 'Yes', value: true },
+          { name: 'No', value: false },
+        ],
+      })
+    : false;
   const formattedAdditionalName = additionalName
     ? additionalName[0].toUpperCase() + additionalName.slice(1)
     : '';

adminforth/commands/createCustomComponent/templates/customCrud/saveButton.vue.hbs

@@ -0,0 +1,28 @@
+<template>
+  <button
+    class="px-4 py-2 border border-blue-500 text-blue-600 rounded hover:bg-blue-50 disabled:opacity-50"
+    :disabled="props.disabled || props.saving || !props.isValid"
+    @click="props.saveRecord()"
+  >
+    <span v-if="props.saving">Saving…</span>
+    <span v-else>Save</span>
+  </button>
+</template>
+
+<script setup lang="ts">
+
+const props = defineProps<{
+  record: any
+  resource: any
+  adminUser: any
+  meta: any
+  saving: boolean
+  validating: boolean
+  isValid: boolean
+  disabled: boolean
+  saveRecord: () => Promise<void>
+}>();
+</script>
+
+<style scoped>
+</style>

adminforth/dataConnectors/baseConnector.ts

@@ -227,11 +227,19 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     throw new Error('Method not implemented.');
   }
 
-  async checkUnique(resource: AdminForthResource, column: AdminForthResourceColumn, value: any) {
+  async checkUnique(resource: AdminForthResource, column: AdminForthResourceColumn, value: any, record?: any): Promise<boolean> {
     process.env.HEAVY_DEBUG && console.log('☝️🪲🪲🪲🪲 checkUnique|||', column, value);
+
+    const primaryKeyField = this.getPrimaryKey(resource);
     const existingRecord = await this.getData({
       resource,
-      filters: { operator: AdminForthFilterOperators.AND, subFilters: [{ field: column.name, operator: AdminForthFilterOperators.EQ, value }]},
+      filters: { 
+        operator: AdminForthFilterOperators.AND, 
+        subFilters: [
+          { field: column.name, operator: AdminForthFilterOperators.EQ, value },
+          ...(record ? [{ field: primaryKeyField, operator: AdminForthFilterOperators.NE as AdminForthFilterOperators.NE, value: record[primaryKeyField] }] : [])
+        ]
+      },
       limit: 1,
       sort: [],
       offset: 0,
@@ -306,7 +314,7 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
   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);
       // todo instead of throwing error, we can just not use setFieldValue here, and pass original value to updateRecordOriginalValues
@@ -319,6 +327,23 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
       }
       recordWithOriginalValues[col.name] = this.setFieldValue(col, newValues[col.name]);
     }
+    const record = await this.getRecordByPrimaryKey(resource, recordId);
+    let error: string | null = null;
+     await Promise.all(
+      resource.dataSourceColumns.map(async (col) => {
+        if (col.isUnique && !col.virtual && !error && Object.prototype.hasOwnProperty.call(recordWithOriginalValues, col.name)) {
+          const exists = await this.checkUnique(resource, col, recordWithOriginalValues[col.name], record);
+          if (exists) {
+            error = `Record with ${col.name} ${recordWithOriginalValues[col.name]} already exists`;
+          }
+        }
+      })
+    );
+    if (error) {
+      process.env.HEAVY_DEBUG && console.log('🪲🆕 check unique error', error);
+      return { error, ok: false };
+    }
+
 
     process.env.HEAVY_DEBUG && console.log(`🪲✏️ updating record id:${recordId}, values: ${JSON.stringify(recordWithOriginalValues)}`);
 

adminforth/dataConnectors/postgres.ts

@@ -97,57 +97,62 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
         rows.forEach((row) => {
             const field: any = {};
             const baseType = row.type.toLowerCase();
-            if (baseType == 'int') {
+            const isPgArray = baseType.endsWith('[]');
+            const normalizedBaseType = isPgArray ? baseType.slice(0, -2) : baseType;
+            if (normalizedBaseType == 'int') {
                 field.type = AdminForthDataTypes.INTEGER;
                 field._underlineType = 'int';
 
-            } else if (baseType.includes('float') || baseType.includes('double')) {
+            } else if (normalizedBaseType.includes('float') || normalizedBaseType.includes('double')) {
                 field.type = AdminForthDataTypes.FLOAT;
                 field._underlineType = 'float';
 
-            } else if (baseType.includes('bool')) {
+            } else if (normalizedBaseType.includes('bool')) {
                 field.type = AdminForthDataTypes.BOOLEAN;
                 field._underlineType = 'bool';
 
-            } else if (baseType == 'uuid') {
+            } else if (normalizedBaseType == 'uuid') {
                 field.type = AdminForthDataTypes.STRING;
                 field._underlineType = 'uuid';
 
-            } else if (baseType.includes('character varying')) {
+            } else if (normalizedBaseType.includes('character varying')) {
                 field.type = AdminForthDataTypes.STRING;
                 field._underlineType = 'varchar';
-                const length = baseType.match(/\d+/);
+                const length = normalizedBaseType.match(/\d+/);
                 field.maxLength = length ? parseInt(length[0]) : null;
 
-            } else if (baseType == 'text') {
+            } else if (normalizedBaseType == 'text') {
                 field.type = AdminForthDataTypes.TEXT;
                 field._underlineType = 'text';
 
-            } else if (baseType.includes('decimal(') || baseType.includes('numeric(')) {
+            } else if (normalizedBaseType.includes('decimal(') || normalizedBaseType.includes('numeric(')) {
                 field.type = AdminForthDataTypes.DECIMAL;
                 field._underlineType = 'decimal';
-                const [precision, scale] = baseType.match(/\d+/g);
+                const [precision, scale] = normalizedBaseType.match(/\d+/g);
                 field.precision = parseInt(precision);
                 field.scale = parseInt(scale);
 
-            } else if (baseType == 'real') {
+            } else if (normalizedBaseType == 'real') {
                 field.type = AdminForthDataTypes.FLOAT;
                 field._underlineType = 'real';
 
-            } else if (baseType == 'date') {
+            } else if (normalizedBaseType == 'date') {
                 field.type = AdminForthDataTypes.DATE;
                 field._underlineType = 'timestamp';
 
-            } else if (baseType.includes('date') || baseType.includes('time')) {
+            } else if (normalizedBaseType.includes('date') || normalizedBaseType.includes('time')) {
                 field.type = AdminForthDataTypes.DATETIME;
                 field._underlineType = 'timestamp';
-            } else if (baseType == 'json' || baseType == 'jsonb') {
+            } else if (normalizedBaseType == 'json' || normalizedBaseType == 'jsonb') {
                 field.type = AdminForthDataTypes.JSON;
                 field._underlineType = 'json';
             } else {
                 field.type = 'unknown'
             }
             field._baseTypeDebug = baseType;
+            if (isPgArray) {
+                field._isPgArray = true;
+            }
             field.primaryKey = row.pk == 1;
             field.default = row.dflt_value;
             field.required = row.notnull && !row.dflt_value;
@@ -211,11 +216,22 @@ class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDa
             } else if (field._underlineType == 'varchar') {
                 return dayjs(value).toISOString();
             }
+        } else if (field.isArray?.enabled) {
+            if (value === null || value === undefined) {
+                return null;
+            }
+            if (field._isPgArray) {
+                return value;
+            }
+            if (field._underlineType == 'json') {
+                return JSON.stringify(value);
+            }
+            return JSON.stringify(value);
         } else if (field.type == AdminForthDataTypes.BOOLEAN) {
             return value === null ? null : (value ? 1 : 0);
         } else if (field.type == AdminForthDataTypes.JSON) {
             if (field._underlineType == 'json') {
-                return value;
+                return typeof value === 'string' || value === null ? value : JSON.stringify(value);
             } else {
                 return JSON.stringify(value);
             }