prisma-safe-ai-query 0.0.0-stage → 1.0.6

package/README.md

@@ -1,3 +1,124 @@
-# Temporary Holding Version
+# 🛡️ Prisma Safe AI Query
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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_model_name_here
+```
+*(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/)

package/dist/agent.d.ts

@@ -0,0 +1,17 @@
+import { SecurityConfig } from "./engine";
+export interface AgentConfig extends SecurityConfig {
+    /** Describe your database tables/columns to help Gemini generate accurate queries (e.g. "Tables available: user, product") */
+    dbContext?: string;
+}
+export declare class PrismaGeminiAgent {
+    private ai;
+    private model;
+    constructor(apiKey?: string, model?: string);
+    /**
+     * Translates a natural language prompt directly into a validated Prisma query.
+     */
+    generateSafeQuery(userPrompt: string, config?: AgentConfig): Promise<{
+        targetTable?: string;
+        where: any;
+    }>;
+}

package/dist/agent.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaGeminiAgent = void 0;
+const genai_1 = require("@google/genai");
+const engine_1 = require("./engine");
+const DEFAULT_MODEL = "gemini-3.1-flash-lite-preview";
+class PrismaGeminiAgent {
+    constructor(apiKey, model) {
+        const key = apiKey || process.env.GEMINI_API_KEY;
+        if (!key) {
+            throw new Error("FATAL ERROR: GEMINI_API_KEY is missing. Pass it to the constructor or set it in your .env file.");
+        }
+        this.ai = new genai_1.GoogleGenAI({ apiKey: key });
+        this.model = model || process.env.GEMINI_MODEL || DEFAULT_MODEL;
+    }
+    /**
+     * Translates a natural language prompt directly into a validated Prisma query.
+     */
+    async generateSafeQuery(userPrompt, config) {
+        const GeminiQuerySchema = {
+            type: genai_1.Type.OBJECT,
+            properties: {
+                targetTable: {
+                    type: genai_1.Type.STRING,
+                    description: "The dynamic database table to query (e.g., 'user', 'product')",
+                },
+                logicalOperator: { type: genai_1.Type.STRING, enum: ["AND", "OR"] },
+                filters: {
+                    type: genai_1.Type.ARRAY,
+                    items: {
+                        type: genai_1.Type.OBJECT,
+                        properties: {
+                            field: { type: genai_1.Type.STRING },
+                            operator: {
+                                type: genai_1.Type.STRING,
+                                enum: [
+                                    "equals",
+                                    "not",
+                                    "in",
+                                    "notIn",
+                                    "lt",
+                                    "lte",
+                                    "gt",
+                                    "gte",
+                                    "contains",
+                                    "startsWith",
+                                    "endsWith",
+                                ],
+                            },
+                            value: { type: genai_1.Type.STRING },
+                        },
+                        required: ["field", "operator", "value"],
+                    },
+                },
+            },
+            required: ["targetTable", "logicalOperator", "filters"],
+        };
+        const instruction = config?.dbContext
+            ? `Convert the user request to database filters. Database Context: ${config.dbContext}`
+            : `Convert the user request to database filters.`;
+        const intentResponse = await this.ai.models.generateContent({
+            model: this.model,
+            contents: [{ role: "user", parts: [{ text: userPrompt }] }],
+            config: {
+                systemInstruction: instruction,
+                responseMimeType: "application/json",
+                responseSchema: GeminiQuerySchema,
+                temperature: 0.1,
+            },
+        });
+        if (!intentResponse.text) {
+            throw new Error("Gemini failed to generate a response.");
+        }
+        // Pass the Gemini JSON through our Zod engine to ensure Allowlist/Blocklist rules are enforced
+        return engine_1.PrismaAIEngine.parseDynamicQuery(intentResponse.text, config);
+    }
+}
+exports.PrismaGeminiAgent = PrismaGeminiAgent;

package/dist/engine.d.ts

@@ -0,0 +1,14 @@
+export interface SecurityConfig {
+    /** Explicitly allow only these fields. If provided, everything else is blocked. */
+    allowList?: string[];
+    /** Explicitly block these fields or tables (supports exact match or dot-notation prefixes like 'user.password'). */
+    blockList?: string[];
+}
+export declare class PrismaAIEngine {
+    private static matchesSecurityRule;
+    private static normalizeFilterValue;
+    static parseDynamicQuery(rawAiOutput: unknown, config?: SecurityConfig): {
+        targetTable?: string;
+        where: any;
+    };
+}

package/dist/engine.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaAIEngine = void 0;
+const schema_1 = require("./schema");
+class PrismaAIEngine {
+    static matchesSecurityRule(value, rule) {
+        const normalizedValue = value.trim();
+        const normalizedRule = rule.trim();
+        if (!normalizedValue || !normalizedRule) {
+            return false;
+        }
+        return normalizedValue === normalizedRule || normalizedValue.startsWith(`${normalizedRule}.`);
+    }
+    static normalizeFilterValue(filter) {
+        const { operator, value } = filter;
+        if (operator === 'in' || operator === 'notIn') {
+            if (Array.isArray(value)) {
+                return value;
+            }
+            if (typeof value === 'string') {
+                const trimmed = value.trim();
+                if (!trimmed) {
+                    return [];
+                }
+                if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        return Array.isArray(parsed) ? parsed : [parsed];
+                    }
+                    catch {
+                        // Fall back to comma-splitting below.
+                    }
+                }
+                return trimmed.includes(',')
+                    ? trimmed.split(',').map(part => part.trim()).filter(Boolean)
+                    : [trimmed];
+            }
+            return [value];
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return value;
+            }
+            try {
+                if ((trimmed.startsWith('[') && trimmed.endsWith(']')) || (trimmed.startsWith('{') && trimmed.endsWith('}'))) {
+                    const parsed = JSON.parse(trimmed);
+                    return parsed;
+                }
+            }
+            catch {
+                // Keep the original string when the value is not valid JSON.
+            }
+        }
+        return value;
+    }
+    static parseDynamicQuery(rawAiOutput, config) {
+        let parsedInput = rawAiOutput;
+        if (typeof rawAiOutput === 'string') {
+            try {
+                parsedInput = JSON.parse(rawAiOutput);
+            }
+            catch (e) {
+                throw new Error("AI output was not valid JSON.");
+            }
+        }
+        const validatedData = schema_1.AIQueryResponseSchema.parse(parsedInput);
+        const targetTable = typeof validatedData.targetTable === 'string' ? validatedData.targetTable.trim() : '';
+        if (!targetTable) {
+            throw new Error('Security Exception: AI output did not include a valid targetTable.');
+        }
+        if (config?.blockList && config.blockList.some(rule => this.matchesSecurityRule(targetTable, rule))) {
+            throw new Error(`Security Exception: AI attempted to query a blocked table -> ${targetTable}`);
+        }
+        if (config?.allowList && !config.allowList.some(rule => this.matchesSecurityRule(targetTable, rule))) {
+            throw new Error(`Security Exception: AI attempted to query a non-allowlisted table -> ${targetTable}`);
+        }
+        const conditions = validatedData.filters.map(filter => {
+            const normalizedField = filter.field.trim();
+            if (config?.blockList && config.blockList.some(rule => this.matchesSecurityRule(normalizedField, rule))) {
+                throw new Error(`Security Exception: AI attempted to query a blocked table or field -> ${normalizedField}`);
+            }
+            if (config?.allowList && !config.allowList.some(rule => this.matchesSecurityRule(normalizedField, rule))) {
+                throw new Error(`Security Exception: AI attempted to query a non-allowlisted field -> ${normalizedField}`);
+            }
+            const normalizedValue = this.normalizeFilterValue(filter);
+            return {
+                [normalizedField]: {
+                    [filter.operator]: normalizedValue
+                }
+            };
+        });
+        const whereClause = conditions.length === 0 ? {} : { [validatedData.logicalOperator]: conditions };
+        return {
+            targetTable,
+            where: whereClause
+        };
+    }
+}
+exports.PrismaAIEngine = PrismaAIEngine;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { PrismaAIEngine, type SecurityConfig } from './engine';
+export { PrismaGeminiAgent, type AgentConfig } from './agent';
+export { AIQueryResponseSchema, PrismaOperatorSchema, type AIQueryResponse } from './schema';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaOperatorSchema = exports.AIQueryResponseSchema = exports.PrismaGeminiAgent = exports.PrismaAIEngine = void 0;
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "PrismaAIEngine", { enumerable: true, get: function () { return engine_1.PrismaAIEngine; } });
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "PrismaGeminiAgent", { enumerable: true, get: function () { return agent_1.PrismaGeminiAgent; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "AIQueryResponseSchema", { enumerable: true, get: function () { return schema_1.AIQueryResponseSchema; } });
+Object.defineProperty(exports, "PrismaOperatorSchema", { enumerable: true, get: function () { return schema_1.PrismaOperatorSchema; } });

package/dist/schema.d.ts

@@ -0,0 +1,49 @@
+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, {
+    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;
+}>;
+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">;
+}, "strip", z.ZodTypeAny, {
+    logicalOperator: "AND" | "OR";
+    filters: {
+        field: string;
+        operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
+        value?: any;
+    }[];
+    targetTable?: string | undefined;
+}, {
+    filters: {
+        field: string;
+        operator: "equals" | "not" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "contains" | "startsWith" | "endsWith";
+        value?: any;
+    }[];
+    targetTable?: string | undefined;
+    logicalOperator?: "AND" | "OR" | undefined;
+}>;
+export type AIQueryResponse = z.infer<typeof AIQueryResponseSchema>;

package/dist/schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIQueryResponseSchema = 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'
+]);
+exports.QueryConditionSchema = zod_1.z.object({
+    field: zod_1.z.string().describe("The database column name (can include dot notation for relations)"),
+    operator: exports.PrismaOperatorSchema,
+    value: zod_1.z.any().describe("The value to filter by"),
+});
+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)
+});

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "prisma-safe-ai-query",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "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"
+  }
+}

package/prisma_safe_ai_query_readme (1).md

@@ -0,0 +1,124 @@
+# 🛡️ 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/)