prisma-safe-ai-query 1.0.6 → 2.0.0

package/dist/introspect.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPrismaSchemaPath = findPrismaSchemaPath;
+exports.parsePrismaSchemaText = parsePrismaSchemaText;
+exports.extractPrismaSchema = extractPrismaSchema;
+exports.formatSchemaForAIContext = formatSchemaForAIContext;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Searches default standard locations for schema.prisma if no explicit path is given.
+ */
+function findPrismaSchemaPath(customPath) {
+    if (customPath) {
+        const resolved = path.resolve(customPath);
+        if (fs.existsSync(resolved))
+            return resolved;
+        return null;
+    }
+    const defaultLocations = [
+        path.resolve(process.cwd(), "prisma", "schema.prisma"),
+        path.resolve(process.cwd(), "schema.prisma"),
+    ];
+    for (const loc of defaultLocations) {
+        if (fs.existsSync(loc))
+            return loc;
+    }
+    return null;
+}
+const SCALAR_TYPES = new Set([
+    "String",
+    "Int",
+    "Float",
+    "Boolean",
+    "DateTime",
+    "Json",
+    "Bytes",
+    "Decimal",
+    "BigInt",
+]);
+/**
+ * Parses raw schema.prisma contents into structured models, relations, foreign keys, and enums,
+ * filtering out datasource URLs, generators, comments, and private credentials.
+ */
+function parsePrismaSchemaText(schemaContent) {
+    const lines = schemaContent.split(/\r?\n/);
+    const models = [];
+    const enums = [];
+    let currentModel = null;
+    let currentEnum = null;
+    for (const rawLine of lines) {
+        const line = rawLine.replace(/\/\/.*$/, "").trim();
+        if (!line)
+            continue;
+        const modelStartMatch = line.match(/^model\s+([A-Za-z0-9_]+)\s*\{/);
+        if (modelStartMatch) {
+            currentModel = { name: modelStartMatch[1], fields: [] };
+            continue;
+        }
+        const enumStartMatch = line.match(/^enum\s+([A-Za-z0-9_]+)\s*\{/);
+        if (enumStartMatch) {
+            currentEnum = { name: enumStartMatch[1], values: [] };
+            continue;
+        }
+        if (line === "}" || line.startsWith("}")) {
+            if (currentModel) {
+                models.push(currentModel);
+                currentModel = null;
+            }
+            if (currentEnum) {
+                enums.push(currentEnum);
+                currentEnum = null;
+            }
+            continue;
+        }
+        if (currentEnum) {
+            const enumVal = line.trim();
+            if (enumVal && /^[A-Za-z0-9_]+$/.test(enumVal)) {
+                currentEnum.values.push(enumVal);
+            }
+            continue;
+        }
+        if (currentModel) {
+            if (line.startsWith("@@"))
+                continue;
+            const tokens = line.split(/\s+/).filter(Boolean);
+            if (tokens.length >= 2) {
+                const fieldName = tokens[0];
+                const fieldType = tokens[1];
+                if (fieldName.startsWith("@"))
+                    continue;
+                const isList = fieldType.endsWith("[]");
+                const isRequired = !fieldType.endsWith("?");
+                const cleanType = fieldType.replace(/[?\[\]]/g, "");
+                // Extract @relation(fields: [userId], references: [id]) if present
+                let relationFromFields;
+                let relationToFields;
+                const fieldsMatch = line.match(/fields:\s*\[([^\]]+)\]/);
+                if (fieldsMatch) {
+                    relationFromFields = fieldsMatch[1]
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                }
+                const refsMatch = line.match(/references:\s*\[([^\]]+)\]/);
+                if (refsMatch) {
+                    relationToFields = refsMatch[1]
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                }
+                const isExplicitRelation = line.includes("@relation") || !SCALAR_TYPES.has(cleanType);
+                currentModel.fields.push({
+                    name: fieldName,
+                    type: cleanType,
+                    isList,
+                    isRequired,
+                    relation: isExplicitRelation,
+                    ...(relationFromFields ? { relationFromFields } : {}),
+                    ...(relationToFields ? { relationToFields } : {}),
+                });
+            }
+        }
+    }
+    // Post-process: Ensure fields whose type is an Enum are marked as non-relations
+    const enumNames = new Set(enums.map((e) => e.name));
+    for (const model of models) {
+        for (const field of model.fields) {
+            if (enumNames.has(field.type)) {
+                field.relation = false;
+            }
+        }
+    }
+    return { models, enums };
+}
+/**
+ * Extracts schema information from a Prisma client instance, DMMF, _runtimeDataModel, or schema file.
+ */
+function extractPrismaSchema(input) {
+    if (input && typeof input === "object") {
+        // 1. Standard DMMF format (Array of models)
+        const dmmf = input.dmmf || input._dmmf;
+        if (dmmf?.datamodel?.models && Array.isArray(dmmf.datamodel.models)) {
+            return {
+                models: dmmf.datamodel.models.map((m) => ({
+                    name: m.name,
+                    fields: (m.fields || []).map((f) => ({
+                        name: f.name,
+                        type: f.type,
+                        isList: Boolean(f.isList),
+                        isRequired: Boolean(f.isRequired),
+                        relation: f.kind === "object",
+                        ...(f.relationFromFields?.length
+                            ? { relationFromFields: f.relationFromFields }
+                            : {}),
+                        ...(f.relationToFields?.length
+                            ? { relationToFields: f.relationToFields }
+                            : {}),
+                    })),
+                })),
+                enums: (dmmf.datamodel.enums || []).map((e) => ({
+                    name: e.name,
+                    values: (e.values || []).map((v) => typeof v === "string" ? v : v.name),
+                })),
+            };
+        }
+        // 2. Prisma v5/v6/v7 _runtimeDataModel format (Record map of models)
+        const runtimeModel = input._runtimeDataModel ||
+            (input.models && !Array.isArray(input.models) ? input : null);
+        if (runtimeModel?.models && typeof runtimeModel.models === "object") {
+            const models = Object.entries(runtimeModel.models).map(([modelName, m]) => ({
+                name: modelName,
+                fields: (m.fields || []).map((f) => ({
+                    name: f.name,
+                    type: f.type,
+                    isList: Boolean(f.isList),
+                    isRequired: Boolean(f.isRequired),
+                    relation: f.kind === "object",
+                    ...(f.relationFromFields?.length
+                        ? { relationFromFields: f.relationFromFields }
+                        : {}),
+                    ...(f.relationToFields?.length
+                        ? { relationToFields: f.relationToFields }
+                        : {}),
+                })),
+            }));
+            const enums = runtimeModel.enums
+                ? Object.entries(runtimeModel.enums).map(([enumName, e]) => ({
+                    name: enumName,
+                    values: (e.values || []).map((v) => typeof v === "string" ? v : v.name),
+                }))
+                : [];
+            return { models, enums };
+        }
+    }
+    // 3. File path resolution
+    const filePath = findPrismaSchemaPath(typeof input === "string" ? input : undefined);
+    if (!filePath) {
+        return { models: [], enums: [] };
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parsePrismaSchemaText(content);
+}
+/**
+ * Formats extracted schema models, foreign-key relationships, and enums into an AI-digestible context string.
+ */
+function formatSchemaForAIContext(schema) {
+    if (!schema.models.length && !schema.enums.length) {
+        return "";
+    }
+    const parts = [];
+    if (schema.models.length > 0) {
+        parts.push("Database Models and Relations:");
+        for (const m of schema.models) {
+            const camelModelName = m.name.charAt(0).toLowerCase() + m.name.slice(1);
+            const fieldStrs = m.fields.map((f) => {
+                let descriptor = `${f.name}: ${f.type}${f.isList ? "[]" : ""}${!f.isRequired ? "?" : ""}`;
+                if (f.relation) {
+                    if (f.relationFromFields?.length && f.relationToFields?.length) {
+                        descriptor += ` (relation to ${f.type} via ${f.relationFromFields.join(",")} -> ${f.relationToFields.join(",")})`;
+                    }
+                    else {
+                        descriptor += ` (relation to ${f.type})`;
+                    }
+                }
+                return descriptor;
+            });
+            parts.push(`- Model ${m.name} (targetTable: "${camelModelName}") { ${fieldStrs.join(", ")} }`);
+        }
+    }
+    if (schema.enums.length > 0) {
+        parts.push("Database Enums:");
+        for (const e of schema.enums) {
+            parts.push(`- Enum ${e.name} [${e.values.join(", ")}]`);
+        }
+    }
+    return parts.join("\n");
+}

package/dist/schema.d.ts

@@ -1,49 +1,39 @@
-import { z } from 'zod';
-export declare const PrismaOperatorSchema: z.ZodEnum<["equals", "not", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith"]>;
-export declare const QueryConditionSchema: z.ZodObject<{
-    field: z.ZodString;
-    operator: z.ZodEnum<["equals", "not", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith"]>;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
+import { z } from "zod";
+export declare const PrismaOperatorSchema: z.ZodEnum<["equals", "not", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith", "some", "every", "none", "is", "isNot"]>;
+export interface QueryCondition {
     field: string;
-    operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
+    operator: z.infer<typeof PrismaOperatorSchema>;
     value?: any;
-}, {
-    field: string;
-    operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
-    value?: any;
-}>;
+}
+export declare const QueryConditionSchema: z.ZodType<QueryCondition>;
+export declare const OrderByDirectionSchema: z.ZodEnum<["asc", "desc"]>;
+export declare const OrderByItemSchema: z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>;
 export declare const AIQueryResponseSchema: z.ZodObject<{
     targetTable: z.ZodOptional<z.ZodString>;
     logicalOperator: z.ZodDefault<z.ZodEnum<["AND", "OR"]>>;
-    filters: z.ZodArray<z.ZodObject<{
-        field: z.ZodString;
-        operator: z.ZodEnum<["equals", "not", "in", "notIn", "lt", "lte", "gt", "gte", "contains", "startsWith", "endsWith"]>;
-        value: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        field: string;
-        operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
-        value?: any;
-    }, {
-        field: string;
-        operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
-        value?: any;
-    }>, "many">;
+    filters: z.ZodArray<z.ZodType<QueryCondition, z.ZodTypeDef, QueryCondition>, "many">;
+    include: z.ZodEffects<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>, Record<string, any> | undefined, unknown>;
+    select: z.ZodEffects<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>, Record<string, any> | undefined, unknown>;
+    orderBy: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodEnum<["asc", "desc"]>>, "many">, z.ZodRecord<z.ZodString, z.ZodAny>]>>, Record<string, any> | Record<string, "asc" | "desc"> | Record<string, "asc" | "desc">[] | undefined, unknown>;
+    take: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodNull]>>, number | undefined, string | number | null | undefined>;
+    skip: z.ZodEffects<z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodNull]>>, number | undefined, string | number | null | undefined>;
 }, "strip", z.ZodTypeAny, {
     logicalOperator: "AND" | "OR";
-    filters: {
-        field: string;
-        operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
-        value?: any;
-    }[];
+    filters: QueryCondition[];
     targetTable?: string | undefined;
+    include?: Record<string, any> | undefined;
+    select?: Record<string, any> | undefined;
+    orderBy?: Record<string, any> | Record<string, "asc" | "desc"> | Record<string, "asc" | "desc">[] | undefined;
+    take?: number | undefined;
+    skip?: number | undefined;
 }, {
-    filters: {
-        field: string;
-        operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
-        value?: any;
-    }[];
+    filters: QueryCondition[];
     targetTable?: string | undefined;
     logicalOperator?: "AND" | "OR" | undefined;
+    include?: unknown;
+    select?: unknown;
+    orderBy?: unknown;
+    take?: string | number | null | undefined;
+    skip?: string | number | null | undefined;
 }>;
 export type AIQueryResponse = z.infer<typeof AIQueryResponseSchema>;

package/dist/schema.js

@@ -1,18 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIQueryResponseSchema = exports.QueryConditionSchema = exports.PrismaOperatorSchema = void 0;
+exports.AIQueryResponseSchema = exports.OrderByItemSchema = exports.OrderByDirectionSchema = exports.QueryConditionSchema = exports.PrismaOperatorSchema = void 0;
 const zod_1 = require("zod");
 exports.PrismaOperatorSchema = zod_1.z.enum([
-    'equals', 'not', 'in', 'notIn', 'lt', 'lte',
-    'gt', 'gte', 'contains', 'startsWith', 'endsWith'
+    "equals",
+    "not",
+    "in",
+    "notIn",
+    "lt",
+    "lte",
+    "gt",
+    "gte",
+    "contains",
+    "startsWith",
+    "endsWith",
+    // Relational list operators
+    "some",
+    "every",
+    "none",
+    // Nullability & existence operators
+    "is",
+    "isNot",
 ]);
-exports.QueryConditionSchema = zod_1.z.object({
-    field: zod_1.z.string().describe("The database column name (can include dot notation for relations)"),
+exports.QueryConditionSchema = zod_1.z.lazy(() => zod_1.z.object({
+    field: zod_1.z
+        .string()
+        .describe("The database column name or relation field (supports dot-notation like 'user.email')"),
     operator: exports.PrismaOperatorSchema,
-    value: zod_1.z.any().describe("The value to filter by"),
-});
+    value: zod_1.z
+        .any()
+        .optional()
+        .describe("The filter value or nested sub-condition"),
+}));
+exports.OrderByDirectionSchema = zod_1.z.enum(["asc", "desc"]);
+exports.OrderByItemSchema = zod_1.z.record(zod_1.z.string(), exports.OrderByDirectionSchema);
+const parseJsonOrObject = (val) => {
+    if (val === null || val === undefined || val === "")
+        return undefined;
+    if (typeof val === "string") {
+        const trimmed = val.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return val;
+};
 exports.AIQueryResponseSchema = zod_1.z.object({
-    targetTable: zod_1.z.string().optional().describe("The dynamic database table to query (e.g., 'user', 'product')"),
-    logicalOperator: zod_1.z.enum(['AND', 'OR']).default('AND'),
-    filters: zod_1.z.array(exports.QueryConditionSchema)
+    targetTable: zod_1.z
+        .string()
+        .optional()
+        .describe("The primary database table to query (e.g., 'subscription', 'user')"),
+    logicalOperator: zod_1.z.enum(["AND", "OR"]).default("AND"),
+    filters: zod_1.z
+        .array(exports.QueryConditionSchema)
+        .describe("Filter conditions for where clause"),
+    include: zod_1.z
+        .preprocess(parseJsonOrObject, zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional())
+        .describe("Relations to include in multi-level queries (nested object structure)"),
+    select: zod_1.z
+        .preprocess(parseJsonOrObject, zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional())
+        .describe("Specific fields to select"),
+    orderBy: zod_1.z
+        .preprocess(parseJsonOrObject, zod_1.z
+        .union([
+        exports.OrderByItemSchema,
+        zod_1.z.array(exports.OrderByItemSchema),
+        zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
+    ])
+        .optional())
+        .describe("Ordering of the results"),
+    take: zod_1.z
+        .union([zod_1.z.number(), zod_1.z.string(), zod_1.z.null()])
+        .optional()
+        .transform((val) => {
+        if (val === null || val === undefined || val === "")
+            return undefined;
+        const parsed = typeof val === "string" ? parseInt(val, 10) : val;
+        if (isNaN(parsed) || parsed <= 0)
+            return undefined;
+        return parsed;
+    })
+        .describe("Maximum number of rows to return (positive integer)"),
+    skip: zod_1.z
+        .union([zod_1.z.number(), zod_1.z.string(), zod_1.z.null()])
+        .optional()
+        .transform((val) => {
+        if (val === null || val === undefined || val === "")
+            return undefined;
+        const parsed = typeof val === "string" ? parseInt(val, 10) : val;
+        if (isNaN(parsed) || parsed < 0)
+            return undefined;
+        return parsed;
+    })
+        .describe("Number of rows to skip (pagination)"),
 });

package/package.json

@@ -1,35 +1,40 @@
-{
-  "name": "prisma-safe-ai-query",
-  "version": "1.0.6",
-  "description": "An end-to-end AI ORM: securely translates natural language into Prisma queries using Google Gemini and Zod.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "test": "npm run build && node --test tests/engine.test.js"
-  },
-  "keywords": [
-    "prisma",
-    "ai",
-    "llm",
-    "gemini",
-    "zod",
-    "security",
-    "orm",
-    "dynamic-routing"
-  ],
-  "author": "Olugbenga Taiwo",
-  "license": "MIT",
-  "dependencies": {
-    "@google/genai": "^1.45.0"
-  },
-  "peerDependencies": {
-    "@prisma/client": ">=5.0.0",
-    "zod": "^3.22.0 || ^4.0.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.7.3",
-    "@types/node": "^22.20.1"
-  }
-}
+{
+  "name": "prisma-safe-ai-query",
+  "version": "2.0.0",
+  "description": "An end-to-end AI ORM: securely translates natural language into Prisma queries using Google Gemini and Zod.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node --test tests/engine.test.js"
+  },
+  "keywords": [
+    "prisma",
+    "ai",
+    "llm",
+    "gemini",
+    "zod",
+    "security",
+    "orm",
+    "multi-level-query"
+  ],
+  "author": "Olugbenga Taiwo",
+  "license": "MIT",
+  "dependencies": {
+    "@google/genai": "^1.45.0"
+  },
+  "peerDependencies": {
+    "@prisma/client": ">=5.0.0",
+    "zod": "^3.22.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/node": "^22.20.1"
+  }
+}

package/prisma_safe_ai_query_readme (1).md

@@ -1,124 +0,0 @@
-# 🛡️ Prisma Safe AI Query
-
-A lightweight, enterprise-grade utility that securely translates natural language into strongly typed, safe Prisma queries using Google Gemini. By bundling `@google/genai` and `zod` directly, this package eliminates all backend boilerplate. You pass in a user prompt, and the package handles the AI orchestration, schema enforcement, and SQL-injection prevention automatically.
-
-## 📦 Installation
-
-```bash
-npm install prisma-safe-ai-query
-```
-*(Requires `@prisma/client` as a peer dependency)*
-
-## 🚀 Quick Start (The PrismaGeminiAgent)
-
-Instead of manually configuring the Gemini SDK, our built-in `PrismaGeminiAgent` handles everything end-to-end.
-
-### 1. Set your API Key
-Ensure you have your Gemini API key in your `.env` file:
-```env
-GEMINI_API_KEY=your_copied_api_key_here
-GEMINI_MODEL=gemini-3.8-flash
-```
-*(Need an API key? Get one for free at [aistudio.google.com](https://aistudio.google.com/))*
-
-## 💬 The Chat Flow (Frontend to Backend)
-
-This package makes it incredibly easy to build a "Chat with your Database" UI. Your frontend remains a simple chat interface, while `PrismaGeminiAgent` handles the heavy lifting on your backend.
-
-### Step 1: The Frontend (React/Vue/Vanilla)
-The user types a natural language query in your chat UI (e.g., *"Show me all active users in London"*). The frontend simply POSTs this message to your backend.
-
-```javascript
-// Example React submit handler
-async function handleChatSubmit(userInput) {
-  const response = await fetch('/api/chat', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ userPrompt: userInput })
-  });
-
-  const result = await response.json();
-
-  if (result.error) return alert(result.error);
-
-  console.log("Safe Database Results:", result.data);
-  // Render results in your chat UI...
-}
-```
-
-### Step 2: The Backend API Route (Next.js / Express)
-Your backend receives the prompt, safely converts it to a Prisma query, executes it dynamically across ANY table, and returns the data.
-
-**Import your Prisma Client**
-```typescript
-// Prisma v5 import
-import { PrismaClient } from '@prisma/client';
-const prisma = new PrismaClient();
-
-// Prisma v6+ import from helper file
-// const prisma = require("./helper/prisma");
-```
-*(Check out my tutorial on [how to install Prisma v7.8.0 in your Express/PostgreSQL project](https://charisintelligence.com.ng/prisma-v7-express-postgresql/))*
-
-**Execute the AI Agent**
-```typescript
-import { PrismaGeminiAgent } from 'prisma-safe-ai-query';
-
-// Automatically picks up GEMINI_API_KEY from process.env
-const aiAgent = new PrismaGeminiAgent(); 
-
-export async function POST(req: Request) {
-  const { userPrompt } = await req.json(); // e.g. "Show me all active users in London"
-
-  try {
-    // 1. One line handles Gemini generation, dynamic routing, and Zod security!
-    const { targetTable, where } = await aiAgent.generateSafeQuery(userPrompt, {
-      dbContext: "Available tables are user, product, and order.", // Helps Gemini route correctly
-      blockList: ['password', 'credit_card'] // Automatically blocks these columns
-    });
-
-    // 2. DYNAMIC ROUTING: Validate the table and execute
-    if (!targetTable || !(targetTable in prisma)) {
-      return new Response(JSON.stringify({ error: "Invalid table requested." }), { status: 400 });
-    }
-
-    // Executes equivalent of prisma.user.findMany(...)
-    const dbResults = await (prisma as any)[targetTable].findMany({
-      where: where,
-      take: 10
-    });
-
-    // 3. Return the data to the frontend chat UI
-    return new Response(JSON.stringify({ data: dbResults }), { status: 200 });
-
-  } catch (error) {
-    return new Response(JSON.stringify({ error: error.message }), { status: 400 });
-  }
-}
-```
-
-## 🔒 Security Configuration
-
-You can strictly control what the AI can and cannot access by passing a configuration object as the second parameter to the `aiAgent.generateSafeQuery()` method.
-
-**Where to configure this:** You should update these settings directly inside your backend controller or API route file (e.g., `app/api/chat/route.ts` in Next.js, or your Express endpoint function) exactly where you process the incoming chat request.
-
-```typescript
-const { targetTable, where } = await aiAgent.generateSafeQuery(userPrompt, {
-  
-  // OPTION 1: Describe your DB to Gemini so it doesn't hallucinate tables. 
-  // A fast hack is to use an AI (like ChatGPT) to generate your dbContext by giving it your prisma schema.
-  dbContext: "We have tables: user, product. User has fields: email, role, status.",
-
-  // OPTION 2: Block specific sensitive fields across all tables
-  blockList: ['passwordHash', 'billingDetails'],
-
-  // OPTION 3: Strict Mode - allow ONLY these fields
-  // allowList: ['status', 'role', 'city']
-});
-```
-
-## 👨‍💻 Author
-Created by **Olugbenga Taiwo**
-- [LinkedIn](https://www.linkedin.com/in/taiwo-olugbenga)
-- [GitHub Profile](https://github.com/oluibk2020/)