@adminforth/bulk-ai-flow 1.0.1

package/index.ts

@@ -0,0 +1,179 @@
+import { AdminForthPlugin, Filters } from "adminforth";
+import type { IAdminForth, IHttpServer, AdminForthResourcePages, AdminForthResourceColumn, AdminForthDataTypes, AdminForthResource } from "adminforth";
+import type { PluginOptions } from './types.js';
+import { json } from "stream/consumers";
+import Handlebars from 'handlebars';
+
+
+export default class  BulkVisionPlugin extends AdminForthPlugin {
+  options: PluginOptions;
+
+  constructor(options: PluginOptions) {
+    super(options, import.meta.url);
+    this.options = options;
+  }
+
+  // Compile Handlebars templates in outputFields using record fields as context
+  private compileOutputFieldsTemplates(record: any): Record<string, string>[] {
+    return this.options.outputFields.map((fieldObj) => {
+      const compiled: Record<string, string> = {};
+      for (const [key, templateStr] of Object.entries(fieldObj)) {
+        try {
+          const tpl = Handlebars.compile(String(templateStr));
+          compiled[key] = tpl(record);
+        } catch {
+          compiled[key] = String(templateStr);
+        }
+      }
+      return compiled;
+    });
+  }
+ 
+  async modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
+    super.modifyResourceConfig(adminforth, resourceConfig);
+
+    //check if options names are provided
+    const columns = this.resourceConfig.columns;
+    let columnEnums = [];
+    for (const field of this.options.outputFields) {
+      for (const [key, value] of Object.entries(field)) {
+        const column = columns.find(c => c.name.toLowerCase() === key.toLowerCase());
+        if (column) {
+          if(column.enum){
+            (field as any)[key] = `${value} Select ${key} from the list (USE ONLY VALUE FIELD. USE ONLY VALUES FROM THIS LIST): ${JSON.stringify(column.enum)}`;
+            columnEnums.push({
+              name: key,
+              enum: column.enum,
+            });
+          }
+        } else {
+          throw new Error(`⚠️ No column found for key "${key}"`);
+        }
+      }
+    }
+
+    const pageInjection = {
+      file: this.componentPath('visionAction.vue'),
+      meta: {
+        pluginInstanceId: this.pluginInstanceId,
+        outputFields: this.options.outputFields,
+        actionName: this.options.actionName,
+        confirmMessage: this.options.confirmMessage,
+        columnEnums: columnEnums,
+      }
+    }
+
+    if (!this.resourceConfig.options.pageInjections) {
+      this.resourceConfig.options.pageInjections = {};
+    }
+    if (!this.resourceConfig.options.pageInjections.list) {
+      this.resourceConfig.options.pageInjections.list = {};
+    }
+
+    this.resourceConfig.options.pageInjections.list.threeDotsDropdownItems = [pageInjection];
+  }
+  
+  validateConfigAfterDiscover(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
+    // optional method where you can safely check field types after database discovery was performed
+  }
+
+  instanceUniqueRepresentation(pluginOptions: any) : string {
+    // optional method to return unique string representation of plugin instance. 
+    // Needed if plugin can have multiple instances on one resource 
+    return `single`;
+  }
+
+  setupEndpoints(server: IHttpServer) {
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/analyze`,
+      handler: async ({ body, adminUser, headers }) => {
+      const selectedIds = body.selectedIds || [];
+      const tasks = selectedIds.map(async (ID) => {
+        // Fetch the record using the provided ID
+        const record = await this.adminforth.resource(this.resourceConfig.resourceId).get( [Filters.EQ('id', ID)] );
+
+        //recieve image URLs to analyze
+        const attachmentFiles = await this.options.attachFiles({ record: record });
+        //create prompt for OpenAI
+        const compiledOutputFields = this.compileOutputFieldsTemplates(record);
+        const prompt = `Analyze the following image(s) and return a single JSON in format like: {'param1': 'value1', 'param2': 'value2'}. 
+          Do NOT return array of objects. Do NOT include any Markdown, code blocks, explanations, or extra text. Only return valid JSON. 
+          Each object must contain the following fields: ${JSON.stringify(compiledOutputFields)} Use the exact field names. If it's number field - return only number.
+          Image URLs:`;
+          
+        //send prompt to OpenAI and get response
+        const chatResponse = await this.options.adapter.generate({ prompt, inputFileUrls: attachmentFiles });
+
+        const resp: any = (chatResponse as any).response;
+        const topLevelError = (chatResponse as any).error;
+        if (topLevelError || resp?.error) {
+          throw new Error(`ERROR: ${JSON.stringify(topLevelError || resp?.error)}`);
+        }
+
+        const textOutput = resp?.output?.[0]?.content?.[0]?.text ?? resp?.output_text ?? resp?.choices?.[0]?.message?.content;
+        if (!textOutput || typeof textOutput !== 'string') {
+          throw new Error('Unexpected AI response format');
+        }
+
+        //parse response and update record
+        const resData = JSON.parse(textOutput);
+
+        return resData;
+      });
+
+      const result = await Promise.all(tasks);
+
+      return { result };
+      }
+    });
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/get_records`,
+      handler: async ( body ) => {
+        let records = [];
+        for( const record of body.body.record ) {
+          records.push(await this.adminforth.resource(this.resourceConfig.resourceId).get( [Filters.EQ('id', record)] ));
+          records[records.length - 1]._label = this.resourceConfig.recordLabel(records[records.length - 1]);
+        }
+        return {
+          records,
+        };
+      }
+    });
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/get_images`,
+      handler: async ( body ) => {
+        let images = [];
+        if(body.body.record){
+          for( const record of body.body.record ) {
+            images.push(await this.options.attachFiles({ record: record }));
+          }
+        }
+        return {
+          images,
+        };
+      }
+    });
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/update_fields`,
+      handler: async ( body ) => {
+        const selectedIds = body.body.selectedIds || [];
+        const fieldsToUpdate = body.body.fields || {};
+        const updates = selectedIds.map((ID, idx) =>
+          this.adminforth
+            .resource(this.resourceConfig.resourceId)
+            .update(ID, fieldsToUpdate[idx])
+        );
+
+        await Promise.all(updates);
+
+      return { ok: true };
+      }
+    });
+  }
+}
+
+

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@adminforth/bulk-ai-flow",
+  "version": "1.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc && rsync -av --exclude 'node_modules' custom dist/"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "devDependencies": {
+    "@types/node": "latest",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "@types/handlebars": "^4.0.40",
+    "adminforth": "^2.4.0-next.101",
+    "handlebars": "^4.7.8"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+      "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include*/ 
+      "module": "node16",                                /* Specify what module code is generated. */
+      "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+      "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules.  */
+      "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+      "strict": false,                                     /* Enable all strict type-checking options. */
+      "skipLibCheck": true,                                 /* Skip type checking all .d.ts files. */
+    },
+    "exclude": ["node_modules", "dist", "custom"],           /* Exclude files from compilation. */
+  }
+  

package/types.ts

@@ -0,0 +1,12 @@
+import { ImageVisionAdapter, AdminUser, IAdminForth, StorageAdapter } from "adminforth";
+
+
+export interface PluginOptions {
+    actionName: string,
+    confirmMessage: string,
+    adapter: ImageVisionAdapter,
+    outputFields: Record<string, string>[],
+    attachFiles?: ({ record }: {
+      record: any,
+    }) => string[] | Promise<string[]>,
+}