Next

adapters/install-adapters.sh

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 ADAPTERS="adminforth-completion-adapter-open-ai-chat-gpt adminforth-email-adapter-aws-ses \
 adminforth-email-adapter-mailgun adminforth-google-oauth-adapter adminforth-github-oauth-adapter \
-adminforth-facebook-oauth-adapter adminforth-keycloak-oauth-adapter adminforth-microsoft-oauth-adapter \ 
-adminforth-twitch-oauth-adapter adminforth-image-generation-adapter-openai adminforth-storage-adapter-amazon-s3 \ 
+adminforth-facebook-oauth-adapter adminforth-keycloak-oauth-adapter adminforth-microsoft-oauth-adapter \
+adminforth-twitch-oauth-adapter adminforth-image-generation-adapter-openai adminforth-storage-adapter-amazon-s3 \
 adminforth-storage-adapter-local adminforth-image-vision-adapter-openai adminforth-key-value-adapter-ram \
 adminforth-login-captcha-adapter-cloudflare adminforth-login-captcha-adapter-recaptcha"
 

adminforth/commands/createCustomComponent/configLoader.js

@@ -2,21 +2,20 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import jiti from 'jiti';
-import dotenv from "dotenv";
+import dotenv, { config } from "dotenv";
 
 dotenv.config({ path: '.env.local', override: true });
 dotenv.config({ path: '.env', override: true });
 
-export async function loadAdminForthConfig() {
+export async function getAdminInstance() {
   const configFileName = 'index.ts';
   const configPath = path.resolve(process.cwd(), configFileName);
-
   try {
     await fs.access(configPath);
   } catch (error) {
     console.error(chalk.red(`\nError: Configuration file not found at ${configPath}`));
     console.error(chalk.yellow(`Please ensure you are running this command from your project's root directory and the '${configFileName}' file exists.`));
-    process.exit(1);
+    return null;
   }
 
   try {
@@ -29,8 +28,19 @@ export async function loadAdminForthConfig() {
     const configModule = _require(configPath);
 
     const adminInstance = configModule.admin || configModule.default?.admin;
+    return { adminInstance, configPath, configFileName };
+  } catch (error) {
+    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath}`));
+    console.error(error);
+    return null;
+  }
+}
 
+export async function loadAdminForthConfig() {
+
+  const { adminInstance, configPath, configFileName } = await getAdminInstance();
 
+  try {
     if (!adminInstance) {
         throw new Error(`Could not find 'admin' export in ${configFileName}. Please ensure your config file exports the AdminForth instance like: 'export const admin = new AdminForth({...});'`);
     }
@@ -53,7 +63,7 @@ export async function loadAdminForthConfig() {
     return config;
 
   } catch (error) {
-    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath}`));
+    console.error(chalk.red(`\nError loading or parsing configuration file: ${configPath},  error: ${error}`));
     console.error(error);
     process.exit(1);
   }

adminforth/commands/createPlugin/templates/package.json.hbs

@@ -5,7 +5,7 @@
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/ && npm version patch"
+    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/"
   },
   "keywords": [],
   "author": "",

adminforth/commands/generateModels.js

@@ -2,6 +2,8 @@ import fs from "fs";
 import path from "path";
 import { toPascalCase, mapToTypeScriptType, getInstance } from "./utils.js";
 import dotenv from "dotenv";
+import { callTsProxy } from "./callTsProxy.js";
+import { getAdminInstance } from "../commands/createCustomComponent/configLoader.js";
 
 const envFileArg = process.argv.find((arg) => arg.startsWith("--env-file="));
 const envFilePath = envFileArg ? envFileArg.split("=")[1] : ".env";
@@ -23,39 +25,45 @@ async function generateModels() {
   }
 
   let modelContent = "// Generated model file\n\n";
-  const files = fs.readdirSync(currentDirectory);
   let instanceFound = false;
 
-  for (const file of files) {
-    if (file.endsWith(".js") || file.endsWith(".ts")) {
-      const instance = await getInstance(file, currentDirectory);
-      if (instance) {
-        await instance.discoverDatabases();
-        instanceFound = true;
-        instance.config.resources.forEach((resource) => {
-          if (resource.columns) {
-            modelContent += `export type ${toPascalCase(
-              resource.resourceId
-            )} = {\n`;
-            resource.columns.forEach((column) => {
-              if (column.name && column.type) {
-                modelContent += `  ${column.name}: ${mapToTypeScriptType(
-                  column.type
-                )};\n`;
+  const { adminInstance, configPath, configFileName } = await getAdminInstance();
+  if (adminInstance) {
+    await adminInstance.discoverDatabases();
+    instanceFound = true;
+    for (const resource of adminInstance.config.resources) {
+      if (resource.columns) {
+        const typeName = toPascalCase(resource.resourceId);
+        const tsCode = `
+          export async function exec() {
+            const columns = ${JSON.stringify(resource.columns)};
+            const typeName = "${typeName}";
+            function mapToTypeScriptType(type) {
+              const map = { "integer": "number", "varchar": "string", "boolean": "boolean", "date": "string", "datetime": "string", "decimal": "number", "float": "number", "json": "Record<string, any>", "text": "string", "string": "string", "time": "string" };
+              return map[type] || "any";
+            }
+
+            let typeStr = \`export type \${typeName} = {\\n\`;
+            for (const col of columns) {
+              if (col.name && col.type) {
+                typeStr += \`  \${col.name}: \${mapToTypeScriptType(col.type)};\\n\`;
               }
-            });
-            modelContent += `}\n\n`;
+            }
+            typeStr += "}\\n\\n";
+            return typeStr;
           }
-        });
+        `;
+
+        const result = await callTsProxy(tsCode);
+        modelContent += result;
       }
-    }
+    };
   }
 
   if (!instanceFound) {
     console.error("Error: No valid instance found to generate models.");
     return;
   }
-
   fs.writeFileSync(modelFilePath, modelContent, "utf-8");
   console.log(`Generated TypeScript model file: ${modelFilePath}`);
   return true;

adminforth/dataConnectors/mongo.ts

@@ -189,6 +189,9 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         } else if (field.type == AdminForthDataTypes.BOOLEAN) {
           return value === null ? null : !!value;
         } else if (field.type == AdminForthDataTypes.DECIMAL) {
+            if (value === null || value === undefined) {
+                return null;
+            }
             return value?.toString();
         }
 
@@ -206,6 +209,9 @@ class MongoConnector extends AdminForthBaseConnector implements IAdminForthDataS
         } else if (field.type == AdminForthDataTypes.BOOLEAN) {
             return value === null ? null : (value ? true : false);
         } else if (field.type == AdminForthDataTypes.DECIMAL) {
+            if (value === null || value === undefined) {
+                return null;
+            }
             return Decimal128.fromString(value?.toString());
         }
         return value;

adminforth/documentation/docs/tutorial/03-Customization/03-virtualColumns.md

@@ -142,10 +142,10 @@ This way, when admin selects, for example, "Luxury" option for "Apartment Type"
 
 ### Custom SQL queries with `insecureRawSQL`
 
-Rarely the sec of Filters supported by AdminForth is not enough for your needs.
+Rarely the set of Filters supported by AdminForth is not enough for your needs.
 In this case you can use `insecureRawSQL` to write your own part of where clause.
 
-However the vital concern that the SQL passed to DB as is, so if you substitute any user inputs it will not be escaped and can lead to SQL injection. To miticate the issue we recommend using `sqlstring` package which will escape the inputs for you.
+However the vital concern that the SQL passed to DB as is, so if you substitute any user inputs it will not be escaped and can lead to SQL injection. To mitigate the issue we recommend using `sqlstring` package which will escape the inputs for you.
 
 ```bash
 npm i sqlstring
@@ -163,7 +163,7 @@ import sqlstring from 'sqlstring';
       if (filter.field === 'some_json_b_field') {
         return {
           // check if some_json_b_field->'$.some_field' is equal to filter.value
-          insecureRawSQL: `some_json_b_field->'$.some_field' = ${sqlstring.escape(filter.value)}`,
+          insecureRawSQL: `some_json_b_field->>'$.some_field' = ${sqlstring.escape(filter.value)}`,
         }
       }
 

adminforth/documentation/docs/tutorial/03-Customization/11-dataApi.md

@@ -123,6 +123,39 @@ const users = await admin.resource('adminuser').list(
 );
 ```
 
+## Using a raw SQL in queries.
+
+Rarely you might want to add ciondition for some exotic SQL but still want to keep the rest of API.
+Technically it happened that AdminForth allows you to do this also
+
+```js
+const minUgcAge = 18;
+const usersWithNoUgcAccess = await admin.resource('adminuser').list(
+  [
+    Filters.NEQ('role', 'Admin'), 
+    {
+       insecureRawSQL: `(user_meta->>'age') < ${sqlstring.escape(minUgcAge)}`
+    }
+
+  ], 15, 0, Sorts.DESC('createdAt')
+);
+
+This will produce next SQL query:
+```
+
+```
+SELECT *
+FROM "adminuser"
+WHERE "role" != 'Admin'
+  AND (user_meta->>'age') < 18
+ORDER BY "createdAt" DESC
+LIMIT 15 OFFSET 0;
+
+```
+
+
+Finds users with age less then 18 from meta field which should be a JSONB field in Postgress.
+
 ## Create a new item in database
 
 Signature: