@neupgroup/mapper 1.2.0 → 1.2.2

package/dist/env.d.ts

@@ -0,0 +1,25 @@
+export type EnvDslConnections = Record<string, Record<string, string>>;
+/**
+ * Parse a simple DSL of the form:
+ * connections = [
+ *   connectionName = [
+ *     key: value,
+ *     key2: "value2",
+ *   ],
+ *   other = [
+ *     type: SQL,
+ *     host: localhost,
+ *   ]
+ * ]
+ */
+export declare function parseConnectionsDsl(text: string): EnvDslConnections;
+export type NormalizedConnection = {
+    name: string;
+    type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api';
+    key: Record<string, any>;
+};
+/**
+ * Convert DSL map to normalized connections compatible with library Connections.
+ * If no explicit type is provided, defaults to 'api'.
+ */
+export declare function toNormalizedConnections(map: EnvDslConnections): NormalizedConnection[];

package/dist/env.js

@@ -0,0 +1,88 @@
+function stripComments(input) {
+    return input
+        .split(/\r?\n/)
+        .map(line => line.replace(/#.*$/, ''))
+        .join('\n');
+}
+function unquote(val) {
+    const trimmed = val.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+/**
+ * Parse a simple DSL of the form:
+ * connections = [
+ *   connectionName = [
+ *     key: value,
+ *     key2: "value2",
+ *   ],
+ *   other = [
+ *     type: SQL,
+ *     host: localhost,
+ *   ]
+ * ]
+ */
+export function parseConnectionsDsl(text) {
+    const cleaned = stripComments(text);
+    const result = {};
+    // Find the connections block
+    const match = cleaned.match(/connections\s*=\s*\[/i);
+    if (!match)
+        return result;
+    // Extract everything after 'connections = [' and before the final ']'
+    const start = match.index + match[0].length;
+    const after = cleaned.slice(start);
+    // naive bracket balance to find end of top-level list
+    let depth = 1;
+    let endIndex = -1;
+    for (let i = 0; i < after.length; i++) {
+        const ch = after[i];
+        if (ch === '[')
+            depth++;
+        else if (ch === ']') {
+            depth--;
+            if (depth === 0) {
+                endIndex = i;
+                break;
+            }
+        }
+    }
+    const inner = endIndex >= 0 ? after.slice(0, endIndex) : after;
+    // Split by connection assignments at top level: name = [ ... ]
+    const connBlocks = inner.split(/\],?/).map(s => s.trim()).filter(Boolean);
+    for (const block of connBlocks) {
+        const assign = block.match(/^(\w[\w-]*)\s*=\s*\[/);
+        if (!assign)
+            continue;
+        const name = assign[1];
+        const content = block.slice(assign[0].length); // inside the [ ...
+        const lines = content.split(/\r?\n|,/).map(l => l.trim()).filter(l => l.length);
+        const map = {};
+        for (const line of lines) {
+            const kv = line.match(/^(\w[\w-]*)\s*:\s*(.+)$/);
+            if (!kv)
+                continue;
+            const key = kv[1];
+            const value = unquote(kv[2].replace(/,\s*$/, ''));
+            map[key] = value;
+        }
+        result[name] = map;
+    }
+    return result;
+}
+/**
+ * Convert DSL map to normalized connections compatible with library Connections.
+ * If no explicit type is provided, defaults to 'api'.
+ */
+export function toNormalizedConnections(map) {
+    const conns = [];
+    for (const [name, kv] of Object.entries(map)) {
+        const rawType = (kv['type'] || kv['dbType'] || '').toLowerCase();
+        const type = ['mysql', 'sql', 'firestore', 'mongodb', 'api'].includes(rawType) ? rawType : 'api';
+        const { type: _omitType, dbType: _omitDbType, ...rest } = kv;
+        conns.push({ name, type, key: rest });
+    }
+    return conns;
+}

package/dist/fluent-mapper.d.ts

@@ -0,0 +1,80 @@
+export declare class FluentQueryBuilder {
+    private mapper;
+    private schemaName;
+    private query;
+    constructor(mapper: any, schemaName: string);
+    where(field: string, value: any, operator?: string): this;
+    whereComplex(raw: string): this;
+    to(update: Record<string, any>): this;
+    get(): Promise<Record<string, any>[]>;
+    getOne(): Promise<Record<string, any> | null>;
+    add(data: Record<string, any>): Promise<any>;
+    update(): Promise<void>;
+    delete(): Promise<void>;
+    deleteOne(): Promise<void>;
+    updateOne(): Promise<void>;
+}
+export declare class FluentConnectionBuilder {
+    private mapper;
+    private connectionName;
+    private connectionType;
+    private connectionConfig;
+    constructor(mapper: any, connectionName: string, connectionType: string, config: Record<string, any>);
+    schema(schemaName: string): FluentSchemaBuilder;
+    query(schemaName: string): FluentQueryBuilder;
+    useConnection(connectionName: string): FluentConnectionSelector;
+}
+export declare class FluentSchemaBuilder {
+    private mapper;
+    private schemaName;
+    private connectionName;
+    constructor(mapper: any, schemaName: string, connectionName: string);
+    collection(collectionName: string): FluentSchemaCollectionBuilder;
+}
+export declare class FluentSchemaCollectionBuilder {
+    private mapper;
+    private schemaName;
+    private connectionName;
+    private collectionName;
+    constructor(mapper: any, schemaName: string, connectionName: string, collectionName: string);
+    structure(structure: Record<string, string> | Array<{
+        name: string;
+        type: string;
+        [key: string]: any;
+    }>): FluentMapper;
+}
+export declare class FluentConnectionSelector {
+    private mapper;
+    private connectionName;
+    constructor(mapper: any, connectionName: string);
+    schema(schemaName: string): FluentSchemaBuilder;
+    query(schemaName: string): FluentQueryBuilder;
+}
+export declare class FluentMapper {
+    private mapper;
+    constructor(mapper: any);
+    query(schemaName: string): FluentQueryBuilder;
+    makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    useConnection(connectionName: string): FluentConnectionSelector;
+    makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
+    getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
+    add(schemaName: string, data: Record<string, any>): Promise<any>;
+    update(schemaName: string, filters: Record<string, any>, data: Record<string, any>): Promise<void>;
+    delete(schemaName: string, filters: Record<string, any>): Promise<void>;
+}
+export declare class StaticMapper {
+    private static instance;
+    private static getFluentMapper;
+    static makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    static useConnection(connectionName: string): FluentConnectionSelector;
+    static makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    static query(schemaName: string): FluentQueryBuilder;
+    static get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
+    static getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
+    static add(schemaName: string, data: Record<string, any>): Promise<any>;
+    static update(schemaName: string, filters: Record<string, any>, data: Record<string, any>): Promise<void>;
+    static delete(schemaName: string, filters: Record<string, any>): Promise<void>;
+}
+export declare const Mapper: typeof StaticMapper;
+export default Mapper;

package/dist/fluent-mapper.js

@@ -0,0 +1,171 @@
+import { createMapper } from './mapper.js';
+export class FluentQueryBuilder {
+    constructor(mapper, schemaName) {
+        this.mapper = mapper;
+        this.schemaName = schemaName;
+        this.query = mapper.use(schemaName);
+    }
+    where(field, value, operator) {
+        this.query.where(field, value, operator);
+        return this;
+    }
+    whereComplex(raw) {
+        this.query.whereComplex(raw);
+        return this;
+    }
+    to(update) {
+        this.query.to(update);
+        return this;
+    }
+    async get() {
+        return this.query.get();
+    }
+    async getOne() {
+        return this.query.getOne();
+    }
+    async add(data) {
+        return this.mapper.add(this.schemaName, data);
+    }
+    async update() {
+        return this.query.update();
+    }
+    async delete() {
+        return this.query.delete();
+    }
+    async deleteOne() {
+        return this.query.deleteOne();
+    }
+    async updateOne() {
+        return this.query.updateOne();
+    }
+}
+export class FluentConnectionBuilder {
+    constructor(mapper, connectionName, connectionType, config) {
+        this.mapper = mapper;
+        this.connectionName = connectionName;
+        this.connectionType = connectionType;
+        this.connectionConfig = config;
+        // Create the connection immediately
+        this.mapper.connect(connectionName, connectionType, config);
+    }
+    schema(schemaName) {
+        return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
+    }
+    query(schemaName) {
+        return new FluentQueryBuilder(this.mapper, schemaName);
+    }
+    useConnection(connectionName) {
+        return new FluentConnectionSelector(this.mapper, connectionName);
+    }
+}
+export class FluentSchemaBuilder {
+    constructor(mapper, schemaName, connectionName) {
+        this.mapper = mapper;
+        this.schemaName = schemaName;
+        this.connectionName = connectionName;
+    }
+    collection(collectionName) {
+        return new FluentSchemaCollectionBuilder(this.mapper, this.schemaName, this.connectionName, collectionName);
+    }
+}
+export class FluentSchemaCollectionBuilder {
+    constructor(mapper, schemaName, connectionName, collectionName) {
+        this.mapper = mapper;
+        this.schemaName = schemaName;
+        this.connectionName = connectionName;
+        this.collectionName = collectionName;
+    }
+    structure(structure) {
+        this.mapper.schema(this.schemaName)
+            .use({ connection: this.connectionName, collection: this.collectionName })
+            .setStructure(structure);
+        return new FluentMapper(this.mapper);
+    }
+}
+export class FluentConnectionSelector {
+    constructor(mapper, connectionName) {
+        this.mapper = mapper;
+        this.connectionName = connectionName;
+    }
+    schema(schemaName) {
+        return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
+    }
+    query(schemaName) {
+        return new FluentQueryBuilder(this.mapper, schemaName);
+    }
+}
+export class FluentMapper {
+    constructor(mapper) {
+        this.mapper = mapper;
+    }
+    query(schemaName) {
+        return new FluentQueryBuilder(this.mapper, schemaName);
+    }
+    makeConnection(name, type, config) {
+        return new FluentConnectionBuilder(this.mapper, name, type, config);
+    }
+    useConnection(connectionName) {
+        return new FluentConnectionSelector(this.mapper, connectionName);
+    }
+    makeTempConnection(type, config) {
+        const tempName = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        return new FluentConnectionBuilder(this.mapper, tempName, type, config);
+    }
+    // Direct query methods for quick usage
+    async get(schemaName, filters) {
+        return this.mapper.get(schemaName, filters);
+    }
+    async getOne(schemaName, filters) {
+        return this.mapper.getOne(schemaName, filters);
+    }
+    async add(schemaName, data) {
+        return this.mapper.add(schemaName, data);
+    }
+    async update(schemaName, filters, data) {
+        return this.mapper.update(schemaName, filters, data);
+    }
+    async delete(schemaName, filters) {
+        return this.mapper.delete(schemaName, filters);
+    }
+}
+// Static API class that provides the fluent interface
+export class StaticMapper {
+    static getFluentMapper() {
+        if (!StaticMapper.instance) {
+            const baseMapper = createMapper();
+            StaticMapper.instance = new FluentMapper(baseMapper);
+        }
+        return StaticMapper.instance;
+    }
+    static makeConnection(name, type, config) {
+        return StaticMapper.getFluentMapper().makeConnection(name, type, config);
+    }
+    static useConnection(connectionName) {
+        return StaticMapper.getFluentMapper().useConnection(connectionName);
+    }
+    static makeTempConnection(type, config) {
+        return StaticMapper.getFluentMapper().makeTempConnection(type, config);
+    }
+    static query(schemaName) {
+        return StaticMapper.getFluentMapper().query(schemaName);
+    }
+    // Direct static methods
+    static async get(schemaName, filters) {
+        return StaticMapper.getFluentMapper().get(schemaName, filters);
+    }
+    static async getOne(schemaName, filters) {
+        return StaticMapper.getFluentMapper().getOne(schemaName, filters);
+    }
+    static async add(schemaName, data) {
+        return StaticMapper.getFluentMapper().add(schemaName, data);
+    }
+    static async update(schemaName, filters, data) {
+        return StaticMapper.getFluentMapper().update(schemaName, filters, data);
+    }
+    static async delete(schemaName, filters) {
+        return StaticMapper.getFluentMapper().delete(schemaName, filters);
+    }
+}
+// Export a default instance for convenience
+export const Mapper = StaticMapper;
+export default Mapper;

package/dist/index.d.ts

@@ -86,3 +86,12 @@ export declare function schema(conns?: Connections): SchemaManager;
 export declare const schemas: SchemaManager;
 export { createOrm } from './orm';
 export type { DbAdapter, QueryOptions };
+export { parseConnectionsDsl, toNormalizedConnections } from './env';
+export type { EnvDslConnections, NormalizedConnection } from './env';
+export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';
+export { Mapper, createMapper } from './mapper';
+export { default } from './mapper';
+export { StaticMapper } from './fluent-mapper';
+export type { FluentQueryBuilder, FluentConnectionBuilder, FluentSchemaBuilder, FluentSchemaCollectionBuilder, FluentConnectionSelector, FluentMapper } from './fluent-mapper';
+export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config';
+export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig, ConfigSchema } from './config';

package/dist/index.js

@@ -276,3 +276,12 @@ export const schemas = (() => {
     return new SchemaManager(conns);
 })();
 export { createOrm } from './orm';
+export { parseConnectionsDsl, toNormalizedConnections } from './env';
+export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';
+// Export the simplified Mapper as default
+export { Mapper, createMapper } from './mapper';
+export { default } from './mapper';
+// Export the new fluent/static API
+export { StaticMapper } from './fluent-mapper';
+// Export the new config-based system
+export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config';

package/dist/mapper.d.ts

@@ -0,0 +1,27 @@
+import { Connections, SchemaManager } from './index';
+export declare class Mapper {
+    private connections;
+    private schemaManager;
+    private static instance;
+    constructor();
+    static getInstance(): Mapper;
+    autoConfigure(): this;
+    private detectEnvironmentConfig;
+    private inferConnectionType;
+    private applyConfig;
+    private applyDefaultConfig;
+    private createSchema;
+    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): this;
+    schema(name: string): ReturnType<SchemaManager['create']>;
+    use(schemaName: string): ReturnType<SchemaManager['use']>;
+    get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
+    getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
+    add(schemaName: string, data: Record<string, any>): Promise<any>;
+    update(schemaName: string, filters: Record<string, any>, data: Record<string, any>): Promise<void>;
+    delete(schemaName: string, filters: Record<string, any>): Promise<void>;
+    getConnections(): Connections;
+    getSchemaManager(): SchemaManager;
+}
+export declare const createMapper: () => Mapper;
+declare const _default: Mapper;
+export default _default;

package/dist/mapper.js

@@ -0,0 +1,144 @@
+import { Connections, SchemaManager } from './index';
+export class Mapper {
+    constructor() {
+        this.connections = new Connections();
+        this.schemaManager = new SchemaManager(this.connections);
+    }
+    static getInstance() {
+        if (!Mapper.instance) {
+            Mapper.instance = new Mapper();
+        }
+        return Mapper.instance;
+    }
+    // Auto-configuration based on environment or defaults
+    autoConfigure() {
+        // Check for environment variables or config files
+        const envConfig = this.detectEnvironmentConfig();
+        if (envConfig) {
+            this.applyConfig(envConfig);
+        }
+        else {
+            // Use sensible defaults
+            this.applyDefaultConfig();
+        }
+        return this;
+    }
+    detectEnvironmentConfig() {
+        // Check for common environment variables or config files
+        if (typeof process !== 'undefined' && process.env) {
+            // Node.js environment
+            const dbUrl = process.env.DATABASE_URL;
+            if (dbUrl) {
+                return {
+                    connection: {
+                        name: 'default',
+                        type: this.inferConnectionType(dbUrl),
+                        key: { url: dbUrl }
+                    }
+                };
+            }
+        }
+        // Check for browser environment with global config
+        if (typeof window !== 'undefined' && window.__MAPPER_CONFIG__) {
+            return window.__MAPPER_CONFIG__;
+        }
+        return null;
+    }
+    inferConnectionType(url) {
+        if (url.includes('mysql'))
+            return 'mysql';
+        if (url.includes('postgres') || url.includes('postgresql'))
+            return 'sql';
+        if (url.includes('mongodb'))
+            return 'mongodb';
+        if (url.includes('firestore'))
+            return 'firestore';
+        return 'api';
+    }
+    applyConfig(config) {
+        if (config.connection) {
+            const conn = config.connection;
+            this.connections.create(conn.name, conn.type).key(conn.key);
+        }
+        if (config.schemas) {
+            for (const schemaConfig of config.schemas) {
+                this.createSchema(schemaConfig);
+            }
+        }
+    }
+    applyDefaultConfig() {
+        // Create a default in-memory connection for quick start
+        this.connections.create('default', 'api').key({ endpoint: 'memory' });
+    }
+    createSchema(config) {
+        const builder = this.schemaManager.create(config.name);
+        if (config.connection && config.collection) {
+            builder.use({ connection: config.connection, collection: config.collection });
+        }
+        if (config.structure) {
+            builder.setStructure(config.structure);
+        }
+    }
+    // Simplified API methods
+    connect(name, type, config) {
+        this.connections.create(name, type).key(config);
+        return this;
+    }
+    schema(name) {
+        return this.schemaManager.create(name);
+    }
+    use(schemaName) {
+        return this.schemaManager.use(schemaName);
+    }
+    // Quick query methods
+    async get(schemaName, filters) {
+        const query = this.use(schemaName);
+        if (filters) {
+            Object.entries(filters).forEach(([field, value]) => {
+                query.where(field, value);
+            });
+        }
+        return query.get();
+    }
+    async getOne(schemaName, filters) {
+        const query = this.use(schemaName);
+        if (filters) {
+            Object.entries(filters).forEach(([field, value]) => {
+                query.where(field, value);
+            });
+        }
+        return query.getOne();
+    }
+    async add(schemaName, data) {
+        return this.use(schemaName).add(data);
+    }
+    async update(schemaName, filters, data) {
+        const query = this.use(schemaName);
+        Object.entries(filters).forEach(([field, value]) => {
+            query.where(field, value);
+        });
+        await query.to(data).update();
+    }
+    async delete(schemaName, filters) {
+        const query = this.use(schemaName);
+        Object.entries(filters).forEach(([field, value]) => {
+            query.where(field, value);
+        });
+        await query.delete();
+    }
+    // Get the underlying managers for advanced usage
+    getConnections() {
+        return this.connections;
+    }
+    getSchemaManager() {
+        return this.schemaManager;
+    }
+}
+// Create and configure the default instance
+export const createMapper = () => {
+    const mapper = Mapper.getInstance();
+    mapper.autoConfigure();
+    return mapper;
+};
+// Export a ready-to-use default instance
+export default createMapper();

package/dist/orm/index.d.ts

@@ -1,8 +1,8 @@
 import type { DbAdapter, QueryOptions } from './types';
 export declare function createOrm(adapter: DbAdapter): {
-    get(options: QueryOptions): Promise<import("@firebase/firestore").DocumentData[]>;
+    get(options: QueryOptions): Promise<import("./types").DocumentData[]>;
     getOne(options: QueryOptions): Promise<any>;
-    getDocuments(options: QueryOptions): Promise<import("@firebase/firestore").DocumentData[]>;
+    getDocuments(options: QueryOptions): Promise<import("./types").DocumentData[]>;
     addDocument(collectionName: string, data: Record<string, any>): Promise<string>;
     updateDocument(collectionName: string, docId: string, data: Record<string, any>): Promise<void>;
     deleteDocument(collectionName: string, docId: string): Promise<void>;

package/dist/orm/types.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentData } from 'firebase/firestore';
+export type DocumentData = Record<string, any>;
 export interface QueryOptions {
     collectionName: string;
     filters: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
   "main": "dist/index.js",
@@ -15,6 +15,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
   }
 }
-

package/dist/actions/ai-operation-suggestion.d.ts

@@ -1,27 +0,0 @@
-import { z } from 'genkit';
-export declare const AIOperationSuggestionInputSchema: z.ZodObject<{
-    operationDescription: z.ZodString;
-    databaseType: z.ZodString;
-    schema: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    databaseType: string;
-    operationDescription: string;
-    schema: string;
-}, {
-    databaseType: string;
-    operationDescription: string;
-    schema: string;
-}>;
-export type AIOperationSuggestionInput = z.infer<typeof AIOperationSuggestionInputSchema>;
-export declare const AIOperationSuggestionOutputSchema: z.ZodObject<{
-    suggestedCode: z.ZodString;
-    rationale: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    rationale: string;
-    suggestedCode: string;
-}, {
-    rationale: string;
-    suggestedCode: string;
-}>;
-export type AIOperationSuggestionOutput = z.infer<typeof AIOperationSuggestionOutputSchema>;
-export declare function createSuggestOperation(ai: any): (input: AIOperationSuggestionInput) => Promise<any>;

package/dist/actions/ai-operation-suggestion.js

@@ -1,46 +0,0 @@
-import { z } from 'genkit';
-export const AIOperationSuggestionInputSchema = z.object({
-    operationDescription: z
-        .string()
-        .describe('A detailed description of the operation to be performed.'),
-    databaseType: z
-        .string()
-        .describe('The type of database (e.g., MongoDB, Firestore, SQL).'),
-    schema: z.string().describe('The JSON schema of the data structure.'),
-});
-export const AIOperationSuggestionOutputSchema = z.object({
-    suggestedCode: z
-        .string()
-        .describe('The suggested code for the operation, as a string.'),
-    rationale: z
-        .string()
-        .describe('Explanation of why the suggested code is optimal.'),
-});
-export function createSuggestOperation(ai) {
-    const aiOperationSuggestionPrompt = ai.definePrompt({
-        name: 'aiOperationSuggestionPrompt',
-        input: { schema: AIOperationSuggestionInputSchema },
-        output: { schema: AIOperationSuggestionOutputSchema },
-        prompt: `You are an expert database engineer. Given a description of a database operation, a database type, and a data schema, you will generate the code to perform that operation. The operation can be for inserting, fetching, or updating data.
-
-Operation Description: {{{operationDescription}}}
-Database Type: {{{databaseType}}}
-Schema: {{{schema}}}
-
-Generate the code for the specified database type. Provide a rationale for the generated code.
-
-Return the suggested code as a string, and include the rationale.
-`,
-    });
-    const aiOperationSuggestionFlow = ai.defineFlow({
-        name: 'aiOperationSuggestionFlow',
-        inputSchema: AIOperationSuggestionInputSchema,
-        outputSchema: AIOperationSuggestionOutputSchema,
-    }, async (input) => {
-        const { output } = await aiOperationSuggestionPrompt(input);
-        return output;
-    });
-    return async function suggestOperation(input) {
-        return aiOperationSuggestionFlow(input);
-    };
-}