@neupgroup/mapper 1.2.0 → 1.2.1

package/dist/docs.d.ts

@@ -0,0 +1,3 @@
+export declare const documentationMd = "\n# Mapper Library Documentation\n\nWelcome to `@neupgroup/mapper`. This guide covers:\n- Installation\n- Configuring connections (DSL and UI)\n- Using connections in code\n- Creating schemas (ORM)\n- Configuring and using schemas\n- CRUD operations: insert, update, delete, fetch\n- Error handling and troubleshooting\n\n---\n\n## Installation\n\n- Install from npm:\n  `npm install @neupgroup/mapper`\n- In this workspace, the app depends on the library via `workspace:*`. Build the library when you update it:\n  `cd library && npm run build`\n- Import helpers:\n  `import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'`\n\n---\n\n## Configure Connections\n\nYou can configure connections in two ways:\n\n1) DSL File (recommended)\n2) UI Configure page (runtime setup)\n\n### 1) DSL Format\n\nCreate `connections.dsl` at your project root:\n\n```\nconnections = [\n  mysql_prod: {\n    type: mysql\n    host: 127.0.0.1\n    port: 3306\n    user: root\n    password: \"s3cr3t\"\n    database: appdb\n  }\n\n  mongo_dev: {\n    type: mongodb\n    uri: \"mongodb://127.0.0.1:27017\"\n    database: devdb\n  }\n\n  firestore_local: {\n    type: firestore\n    projectId: my-project\n    applicationDefault: true\n  }\n\n  http_api: {\n    type: api\n    baseUrl: \"https://api.example.com\"\n    token: \"abc123\"\n  }\n]\n```\n\nNotes:\n- `type` (or `dbType`) defaults to `api` if omitted.\n- Values can be unquoted or quoted; comments using `#` are ignored.\n\nParse and normalize:\n\n```ts\nimport { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'\n\nconst text = await fs.promises.readFile('connections.dsl', 'utf8')\nconst envMap = parseConnectionsDsl(text)\nconst connections = toNormalizedConnections(envMap)\n// connections: Array<{ name, type, key }>\n```\n\n### 2) UI Configure Page\n\n- Go to `/configure` to define connections at runtime.\n- Use \"Generate collective env\" to produce `connections.dsl` from configured connections.\n- Download the file and commit it or load at startup.\n\n---\n\n## Use Connections in Code\n\n### Normalize and route by type\n\n```ts\nimport { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'\nimport { connection, schema } from '@neupgroup/mapper'\n\nconst text = await fs.promises.readFile('connections.dsl', 'utf8')\nconst envMap = parseConnectionsDsl(text)\nconst conns = toNormalizedConnections(envMap)\n\n// Register connections\nconst conRegistry = connection()\nfor (const c of conns) {\n  conRegistry.register({ name: c.name, type: c.type, key: c.key })\n}\n\n// Use with schemas\nconst sm = schema(conRegistry)\n```\n\n### Direct construction\n\n```ts\nconst conRegistry = connection()\nconRegistry.create('mysql_prod', 'mysql').key({\n  host: '127.0.0.1',\n  port: 3306,\n  user: 'root',\n  password: 's3cr3t',\n  database: 'appdb',\n})\n```\n\n---\n\n## Schemas and Models\n\nSchemas define structure for collections/tables bound to a connection.\n\n### Define and register a schema\n\n```ts\nimport { schema } from '@neupgroup/mapper'\n\nconst sm = schema(conRegistry)\n\nsm.create('User')\n  .use({ connection: 'mysql_prod', collection: 'users' })\n  .setStructure({\n    id: 'string primary',\n    email: 'string unique',\n    name: 'string editable',\n    createdAt: 'date',\n    '?field': 'allow-undefined', // optional: permit fields not listed\n  })\n\nconst User = sm.use('User')\n```\n\n---\n\n## CRUD Operations\n\nAll operations return Promises and may throw on errors.\n\n### Insert\n\n```ts\nconst createdId = await User.add({\n  id: 'u_123',\n  email: 'alice@example.com',\n  name: 'Alice',\n  createdAt: new Date(),\n})\n```\n\n### Update\n\n```ts\nawait User.where(['id', 'u_123']).to({ name: 'Alice Cooper' }).updateOne()\n```\n\n### Delete\n\n```ts\nawait User.where(['id', 'u_123']).deleteOne()\n```\n\n### Fetch / Query\n\n```ts\nconst one = await User.where(['id', 'u_123']).getOne()\nconst many = await User.where('email', '%@example.com', 'like').get()\n```\n\n---\n\n## Schema Configuration Details\n\n- `primary`: marks primary key; used for updates/deletes.\n- `unique`: enforces uniqueness in supported backends.\n- `editable`: indicates fields commonly modified via UI.\n- `type`: one of `string`, `number`, `boolean`, `date`, `int`.\n- `?field`: enables accepting fields not defined in the schema.\n\n---\n\n## Error Handling\n\nWrap operations in `try/catch` and inspect known error shapes.\n\n```ts\ntry {\n  const user = await User.where(['id', 'u_404']).getOne()\n  if (!user) {\n    // handle not found gracefully\n  }\n} catch (err) {\n  if (err && typeof err === 'object' && 'code' in err) {\n    console.error('Database error code:', (err as any).code)\n  }\n  console.error('Unexpected error', err)\n}\n```\n\nRecommendations:\n- Validate required creds before initializing connections.\n- Prefer parameterized queries or ORM filters over string concatenation.\n- Log request IDs and timestamps for audit trails.\n\n---\n\n## Troubleshooting\n\n- \"Connection refused\": check host/port/firewall and credentials.\n- \"Authentication failed\": verify tokens/passwords and token scopes.\n- \"Timeout\": review network paths and optimize query.\n- \"Schema mismatch\": ensure field names/types match the backend.\n\n---\n\n## API Quick Reference\n\n- `parseConnectionsDsl(text)` \u2192 Map of connectionName \u2192 key/value creds\n- `toNormalizedConnections(map)` \u2192 Array of { name, type, key }\n- `connection()` \u2192 Connection registry (create/register/list/get)\n- `schema(connections?)` \u2192 Schema manager; define, register, and use schemas\n\n---\n\n## End-to-End Example\n\n```ts\nimport { parseConnectionsDsl, toNormalizedConnections, connection, schema } from '@neupgroup/mapper'\n\nconst text = await fs.promises.readFile('connections.dsl', 'utf8')\nconst map = parseConnectionsDsl(text)\nconst conns = toNormalizedConnections(map)\n\nconst conRegistry = connection()\nfor (const c of conns) conRegistry.register({ name: c.name, type: c.type, key: c.key })\n\nconst sm = schema(conRegistry)\nsm.create('Product')\n  .use({ connection: conns[0].name, collection: 'products' })\n  .setStructure({\n    id: 'string primary',\n    title: 'string',\n    price: 'number',\n    tags: 'string',\n  })\nconst Product = sm.use('Product')\n\nawait Product.add({ id: 'p_1', title: 'Widget', price: 9.99, tags: 'sale' })\nawait Product.where(['id', 'p_1']).to({ price: 7.99 }).updateOne()\nconst items = await Product.where('price', 10, '<').get()\nawait Product.where(['id', 'p_1']).deleteOne()\n```\n";
+export declare function markdownToHtml(md: string): string;
+export declare function getDocumentationHtml(): string;

package/dist/docs.js

@@ -0,0 +1,351 @@
+// Centralized documentation for @neupgroup/mapper.
+// Exports Markdown plus a minimal Markdown→HTML converter so apps can render
+// without a heavy dependency. Keep content comprehensive and up-to-date.
+export const documentationMd = `
+# Mapper Library Documentation
+
+Welcome to \`@neupgroup/mapper\`. This guide covers:
+- Installation
+- Configuring connections (DSL and UI)
+- Using connections in code
+- Creating schemas (ORM)
+- Configuring and using schemas
+- CRUD operations: insert, update, delete, fetch
+- Error handling and troubleshooting
+
+---
+
+## Installation
+
+- Install from npm:
+  \`npm install @neupgroup/mapper\`
+- In this workspace, the app depends on the library via \`workspace:*\`. Build the library when you update it:
+  \`cd library && npm run build\`
+- Import helpers:
+  \`import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'\`
+
+---
+
+## Configure Connections
+
+You can configure connections in two ways:
+
+1) DSL File (recommended)
+2) UI Configure page (runtime setup)
+
+### 1) DSL Format
+
+Create \`connections.dsl\` at your project root:
+
+\`\`\`
+connections = [
+  mysql_prod: {
+    type: mysql
+    host: 127.0.0.1
+    port: 3306
+    user: root
+    password: "s3cr3t"
+    database: appdb
+  }
+
+  mongo_dev: {
+    type: mongodb
+    uri: "mongodb://127.0.0.1:27017"
+    database: devdb
+  }
+
+  firestore_local: {
+    type: firestore
+    projectId: my-project
+    applicationDefault: true
+  }
+
+  http_api: {
+    type: api
+    baseUrl: "https://api.example.com"
+    token: "abc123"
+  }
+]
+\`\`\`
+
+Notes:
+- \`type\` (or \`dbType\`) defaults to \`api\` if omitted.
+- Values can be unquoted or quoted; comments using \`#\` are ignored.
+
+Parse and normalize:
+
+\`\`\`ts
+import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'
+
+const text = await fs.promises.readFile('connections.dsl', 'utf8')
+const envMap = parseConnectionsDsl(text)
+const connections = toNormalizedConnections(envMap)
+// connections: Array<{ name, type, key }>
+\`\`\`
+
+### 2) UI Configure Page
+
+- Go to \`/configure\` to define connections at runtime.
+- Use \"Generate collective env\" to produce \`connections.dsl\` from configured connections.
+- Download the file and commit it or load at startup.
+
+---
+
+## Use Connections in Code
+
+### Normalize and route by type
+
+\`\`\`ts
+import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'
+import { connection, schema } from '@neupgroup/mapper'
+
+const text = await fs.promises.readFile('connections.dsl', 'utf8')
+const envMap = parseConnectionsDsl(text)
+const conns = toNormalizedConnections(envMap)
+
+// Register connections
+const conRegistry = connection()
+for (const c of conns) {
+  conRegistry.register({ name: c.name, type: c.type, key: c.key })
+}
+
+// Use with schemas
+const sm = schema(conRegistry)
+\`\`\`
+
+### Direct construction
+
+\`\`\`ts
+const conRegistry = connection()
+conRegistry.create('mysql_prod', 'mysql').key({
+  host: '127.0.0.1',
+  port: 3306,
+  user: 'root',
+  password: 's3cr3t',
+  database: 'appdb',
+})
+\`\`\`
+
+---
+
+## Schemas and Models
+
+Schemas define structure for collections/tables bound to a connection.
+
+### Define and register a schema
+
+\`\`\`ts
+import { schema } from '@neupgroup/mapper'
+
+const sm = schema(conRegistry)
+
+sm.create('User')
+  .use({ connection: 'mysql_prod', collection: 'users' })
+  .setStructure({
+    id: 'string primary',
+    email: 'string unique',
+    name: 'string editable',
+    createdAt: 'date',
+    '?field': 'allow-undefined', // optional: permit fields not listed
+  })
+
+const User = sm.use('User')
+\`\`\`
+
+---
+
+## CRUD Operations
+
+All operations return Promises and may throw on errors.
+
+### Insert
+
+\`\`\`ts
+const createdId = await User.add({
+  id: 'u_123',
+  email: 'alice@example.com',
+  name: 'Alice',
+  createdAt: new Date(),
+})
+\`\`\`
+
+### Update
+
+\`\`\`ts
+await User.where(['id', 'u_123']).to({ name: 'Alice Cooper' }).updateOne()
+\`\`\`
+
+### Delete
+
+\`\`\`ts
+await User.where(['id', 'u_123']).deleteOne()
+\`\`\`
+
+### Fetch / Query
+
+\`\`\`ts
+const one = await User.where(['id', 'u_123']).getOne()
+const many = await User.where('email', '%@example.com', 'like').get()
+\`\`\`
+
+---
+
+## Schema Configuration Details
+
+- \`primary\`: marks primary key; used for updates/deletes.
+- \`unique\`: enforces uniqueness in supported backends.
+- \`editable\`: indicates fields commonly modified via UI.
+- \`type\`: one of \`string\`, \`number\`, \`boolean\`, \`date\`, \`int\`.
+- \`?field\`: enables accepting fields not defined in the schema.
+
+---
+
+## Error Handling
+
+Wrap operations in \`try/catch\` and inspect known error shapes.
+
+\`\`\`ts
+try {
+  const user = await User.where(['id', 'u_404']).getOne()
+  if (!user) {
+    // handle not found gracefully
+  }
+} catch (err) {
+  if (err && typeof err === 'object' && 'code' in err) {
+    console.error('Database error code:', (err as any).code)
+  }
+  console.error('Unexpected error', err)
+}
+\`\`\`
+
+Recommendations:
+- Validate required creds before initializing connections.
+- Prefer parameterized queries or ORM filters over string concatenation.
+- Log request IDs and timestamps for audit trails.
+
+---
+
+## Troubleshooting
+
+- \"Connection refused\": check host/port/firewall and credentials.
+- \"Authentication failed\": verify tokens/passwords and token scopes.
+- \"Timeout\": review network paths and optimize query.
+- \"Schema mismatch\": ensure field names/types match the backend.
+
+---
+
+## API Quick Reference
+
+- \`parseConnectionsDsl(text)\` → Map of connectionName → key/value creds
+- \`toNormalizedConnections(map)\` → Array of { name, type, key }
+- \`connection()\` → Connection registry (create/register/list/get)
+- \`schema(connections?)\` → Schema manager; define, register, and use schemas
+
+---
+
+## End-to-End Example
+
+\`\`\`ts
+import { parseConnectionsDsl, toNormalizedConnections, connection, schema } from '@neupgroup/mapper'
+
+const text = await fs.promises.readFile('connections.dsl', 'utf8')
+const map = parseConnectionsDsl(text)
+const conns = toNormalizedConnections(map)
+
+const conRegistry = connection()
+for (const c of conns) conRegistry.register({ name: c.name, type: c.type, key: c.key })
+
+const sm = schema(conRegistry)
+sm.create('Product')
+  .use({ connection: conns[0].name, collection: 'products' })
+  .setStructure({
+    id: 'string primary',
+    title: 'string',
+    price: 'number',
+    tags: 'string',
+  })
+const Product = sm.use('Product')
+
+await Product.add({ id: 'p_1', title: 'Widget', price: 9.99, tags: 'sale' })
+await Product.where(['id', 'p_1']).to({ price: 7.99 }).updateOne()
+const items = await Product.where('price', 10, '<').get()
+await Product.where(['id', 'p_1']).deleteOne()
+\`\`\`
+`;
+// Minimal Markdown → HTML converter (headings, lists, code fences, inline code, paragraphs)
+export function markdownToHtml(md) {
+    const lines = md.split(/\r?\n/);
+    let html = [];
+    let inCode = false;
+    let codeBuf = [];
+    function escapeHtml(s) {
+        return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+    function inline(s) {
+        s = s.replace(/`([^`]+)`/g, (_m, g1) => `<code>${escapeHtml(g1)}</code>`);
+        s = s.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+        s = s.replace(/\*([^*]+)\*/g, '<em>$1</em>');
+        s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+        return s;
+    }
+    function flushParagraph(buf) {
+        const text = buf.join(' ').trim();
+        if (!text)
+            return;
+        html.push(`<p>${inline(escapeHtml(text))}</p>`);
+        buf.length = 0;
+    }
+    let paraBuf = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('```')) {
+            if (inCode) {
+                html.push(`<pre><code>${escapeHtml(codeBuf.join('\n'))}</code></pre>`);
+                codeBuf = [];
+                inCode = false;
+            }
+            else {
+                flushParagraph(paraBuf);
+                inCode = true;
+            }
+            continue;
+        }
+        if (inCode) {
+            codeBuf.push(line);
+            continue;
+        }
+        const hMatch = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (hMatch) {
+            flushParagraph(paraBuf);
+            const level = hMatch[1].length;
+            const content = hMatch[2];
+            html.push(`<h${level}>${inline(escapeHtml(content))}</h${level}>`);
+            continue;
+        }
+        if (/^\s*[-*]\s+/.test(line)) {
+            flushParagraph(paraBuf);
+            let ulItems = [];
+            ulItems.push(line.replace(/^\s*[-*]\s+/, ''));
+            while (i + 1 < lines.length && /^\s*[-*]\s+/.test(lines[i + 1])) {
+                i++;
+                ulItems.push(lines[i].replace(/^\s*[-*]\s+/, ''));
+            }
+            const lis = ulItems.map(item => `<li>${inline(escapeHtml(item))}</li>`).join('');
+            html.push(`<ul>${lis}</ul>`);
+            continue;
+        }
+        if (/^\s*$/.test(line)) {
+            flushParagraph(paraBuf);
+            continue;
+        }
+        paraBuf.push(line);
+    }
+    if (inCode) {
+        html.push(`<pre><code>${codeBuf.map(s => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')).join('\n')}</code></pre>`);
+    }
+    flushParagraph(paraBuf);
+    return html.join('\n');
+}
+export function getDocumentationHtml() {
+    return markdownToHtml(documentationMd);
+}

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/index.d.ts

@@ -86,3 +86,6 @@ 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';

package/dist/index.js

@@ -276,3 +276,5 @@ export const schemas = (() => {
     return new SchemaManager(conns);
 })();
 export { createOrm } from './orm';
+export { parseConnectionsDsl, toNormalizedConnections } from './env';
+export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
   "main": "dist/index.js",

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);
-    };
-}

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

@@ -1,24 +0,0 @@
-import { z } from 'genkit';
-export declare const AISchemaSuggestionInputSchema: z.ZodObject<{
-    dataDescription: z.ZodString;
-    databaseType: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    dataDescription: string;
-    databaseType: string;
-}, {
-    dataDescription: string;
-    databaseType: string;
-}>;
-export type AISchemaSuggestionInput = z.infer<typeof AISchemaSuggestionInputSchema>;
-export declare const AISchemaSuggestionOutputSchema: z.ZodObject<{
-    suggestedSchema: z.ZodString;
-    rationale: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    suggestedSchema: string;
-    rationale: string;
-}, {
-    suggestedSchema: string;
-    rationale: string;
-}>;
-export type AISchemaSuggestionOutput = z.infer<typeof AISchemaSuggestionOutputSchema>;
-export declare function createSuggestSchema(ai: any): (input: AISchemaSuggestionInput) => Promise<any>;

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

@@ -1,46 +0,0 @@
-import { z } from 'genkit';
-export const AISchemaSuggestionInputSchema = z.object({
-    dataDescription: z
-        .string()
-        .describe('A detailed description of the data that the schema should represent.'),
-    databaseType: z
-        .string()
-        .describe('The type of database for which the schema is being created (e.g., MongoDB, Firestore, SQL).'),
-});
-export const AISchemaSuggestionOutputSchema = z.object({
-    suggestedSchema: z
-        .string()
-        .describe('The suggested schema structure, formatted as a JSON string, tailored for the specified database type.'),
-    rationale: z
-        .string()
-        .describe('Explanation of why the suggested schema is optimal for the given data description and database type.'),
-});
-export function createSuggestSchema(ai) {
-    const aiSchemaSuggestionPrompt = ai.definePrompt({
-        name: 'aiSchemaSuggestionPrompt',
-        input: { schema: AISchemaSuggestionInputSchema },
-        output: { schema: AISchemaSuggestionOutputSchema },
-        prompt: `You are an expert database architect. Given a description of data and a database type, you will suggest an optimal schema structure.
-
-Data Description: {{{dataDescription}}}
-Database Type: {{{databaseType}}}
-
-Consider the characteristics and constraints of the specified database type when formulating the schema.
-
-Return the suggested schema as a JSON string, and include a rationale explaining why the schema is optimal.
-
-Ensure that the suggested schema is valid and can be directly used with the specified database.
-`,
-    });
-    const aiSchemaSuggestionFlow = ai.defineFlow({
-        name: 'aiSchemaSuggestionFlow',
-        inputSchema: AISchemaSuggestionInputSchema,
-        outputSchema: AISchemaSuggestionOutputSchema,
-    }, async (input) => {
-        const { output } = await aiSchemaSuggestionPrompt(input);
-        return output;
-    });
-    return async function suggestSchema(input) {
-        return aiSchemaSuggestionFlow(input);
-    };
-}