@neupgroup/mapper 1.3.0 → 1.4.0

package/dist/adapters/api-adapter.d.ts

@@ -34,10 +34,7 @@ export declare class APIAdapter implements DbAdapter {
     addDocument(collectionName: string, data: DocumentData): Promise<string>;
     updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
     deleteDocument(collectionName: string, docId: string): Promise<void>;
-    /**
-     * Make a custom API request
-     */
-    request(method: string, endpoint: string, data?: any, customHeaders?: Record<string, string>): Promise<any>;
+    request(method: string, endpoint: string, data?: any, customHeaders?: Record<string, string | string[]>): Promise<any>;
 }
 /**
  * Factory function to create API adapter

package/dist/adapters/api-adapter.js

@@ -69,13 +69,23 @@ export class APIAdapter {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
         try {
+            const headers = new Headers({
+                'Content-Type': 'application/json',
+                ...this.config.headers,
+            });
+            if (options.headers) {
+                Object.entries(options.headers).forEach(([key, value]) => {
+                    if (Array.isArray(value)) {
+                        value.forEach(v => headers.append(key, v));
+                    }
+                    else if (value !== undefined) {
+                        headers.set(key, value);
+                    }
+                });
+            }
             const response = await fetch(url, {
                 ...options,
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.config.headers,
-                    ...options.headers,
-                },
+                headers,
                 signal: controller.signal,
             });
             clearTimeout(timeoutId);
@@ -150,9 +160,6 @@ export class APIAdapter {
         });
         await this.fetch(url, { method: 'DELETE' });
     }
-    /**
-     * Make a custom API request
-     */
     async request(method, endpoint, data, customHeaders) {
         const url = `${this.config.baseUrl}${endpoint}`;
         return this.fetch(url, {

package/dist/adapters/index.d.ts

@@ -2,11 +2,13 @@ export { MySQLAdapter, createMySQLAdapter, type MySQLConfig } from './mysql-adap
 export { PostgreSQLAdapter, createPostgreSQLAdapter, type PostgreSQLConfig } from './postgres-adapter.js';
 export { MongoDBAdapter, createMongoDBAdapter, type MongoDBConfig } from './mongodb-adapter.js';
 export { APIAdapter, createAPIAdapter, type APIAdapterConfig } from './api-adapter.js';
+export { SQLiteAdapter, createSQLiteAdapter, type SQLiteConfig } from './sqlite-adapter.js';
 import type { DbAdapter } from '../orm/types.js';
 import { type MySQLConfig } from './mysql-adapter.js';
 import { type PostgreSQLConfig } from './postgres-adapter.js';
 import { type MongoDBConfig } from './mongodb-adapter.js';
 import { type APIAdapterConfig } from './api-adapter.js';
+import { type SQLiteConfig } from './sqlite-adapter.js';
 export type AdapterConfig = {
     type: 'mysql';
     config: MySQLConfig;
@@ -19,6 +21,9 @@ export type AdapterConfig = {
 } | {
     type: 'api' | 'rest';
     config: APIAdapterConfig;
+} | {
+    type: 'sqlite' | 'sqlite3';
+    config: SQLiteConfig;
 };
 /**
  * Auto-create adapter based on connection type

package/dist/adapters/index.js

@@ -3,10 +3,12 @@ export { MySQLAdapter, createMySQLAdapter } from './mysql-adapter.js';
 export { PostgreSQLAdapter, createPostgreSQLAdapter } from './postgres-adapter.js';
 export { MongoDBAdapter, createMongoDBAdapter } from './mongodb-adapter.js';
 export { APIAdapter, createAPIAdapter } from './api-adapter.js';
+export { SQLiteAdapter, createSQLiteAdapter } from './sqlite-adapter.js';
 import { createMySQLAdapter } from './mysql-adapter.js';
 import { createPostgreSQLAdapter } from './postgres-adapter.js';
 import { createMongoDBAdapter } from './mongodb-adapter.js';
 import { createAPIAdapter } from './api-adapter.js';
+import { createSQLiteAdapter } from './sqlite-adapter.js';
 /**
  * Auto-create adapter based on connection type
  */
@@ -24,6 +26,9 @@ export function createAdapter(adapterConfig) {
         case 'api':
         case 'rest':
             return createAPIAdapter(adapterConfig.config);
+        case 'sqlite':
+        case 'sqlite3':
+            return createSQLiteAdapter(adapterConfig.config);
         default:
             throw new Error(`Unknown adapter type: ${adapterConfig.type}`);
     }
@@ -32,6 +37,10 @@ export function createAdapter(adapterConfig) {
  * Create adapter from connection URL
  */
 export function createAdapterFromUrl(url) {
+    // Handle shorthand SQLite local files
+    if (url.endsWith('.db') || url.endsWith('.sqlite')) {
+        return createSQLiteAdapter({ filename: url });
+    }
     const urlObj = new URL(url);
     const protocol = urlObj.protocol.replace(':', '');
     switch (protocol) {
@@ -62,6 +71,11 @@ export function createAdapterFromUrl(url) {
             return createAPIAdapter({
                 baseUrl: url,
             });
+        case 'sqlite':
+        case 'sqlite3':
+            return createSQLiteAdapter({
+                filename: url.replace('sqlite://', '').replace('sqlite3://', ''),
+            });
         default:
             throw new Error(`Unsupported protocol: ${protocol}`);
     }

package/dist/adapters/sqlite-adapter.d.ts

@@ -0,0 +1,36 @@
+import type { DbAdapter, QueryOptions, DocumentData } from '../orm/types';
+export interface SQLiteConfig {
+    filename: string;
+    mode?: number;
+}
+/**
+ * SQLite Database Adapter
+ * Requires: npm install sqlite3
+ */
+export declare class SQLiteAdapter implements DbAdapter {
+    private db;
+    private sqlite3;
+    constructor(config: SQLiteConfig);
+    private run;
+    private all;
+    private getRow;
+    private buildWhereClause;
+    get(options: QueryOptions): Promise<DocumentData[]>;
+    getOne(options: QueryOptions): Promise<DocumentData | null>;
+    getDocuments(options: QueryOptions): Promise<DocumentData[]>;
+    addDocument(collectionName: string, data: DocumentData): Promise<string>;
+    updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
+    deleteDocument(collectionName: string, docId: string): Promise<void>;
+    /**
+     * Close the database connection
+     */
+    close(): Promise<void>;
+    /**
+     * Execute a raw SQL query
+     */
+    raw(sql: string, values?: any[]): Promise<any>;
+}
+/**
+ * Factory function to create SQLite adapter
+ */
+export declare function createSQLiteAdapter(config: SQLiteConfig): SQLiteAdapter;

package/dist/adapters/sqlite-adapter.js

@@ -0,0 +1,172 @@
+/**
+ * SQLite Database Adapter
+ * Requires: npm install sqlite3
+ */
+export class SQLiteAdapter {
+    constructor(config) {
+        try {
+            // Dynamically import sqlite3 to avoid bundling if not used
+            this.sqlite3 = require('sqlite3').verbose();
+            this.db = new this.sqlite3.Database(config.filename, config.mode);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize SQLite adapter: ${error.message}\n` +
+                `Make sure to install sqlite3: npm install sqlite3`);
+        }
+    }
+    run(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.run(sql, params, function (err) {
+                if (err)
+                    reject(err);
+                else
+                    resolve(this);
+            });
+        });
+    }
+    all(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.all(sql, params, (err, rows) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(rows);
+            });
+        });
+    }
+    getRow(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            this.db.get(sql, params, (err, row) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(row);
+            });
+        });
+    }
+    buildWhereClause(options) {
+        const values = [];
+        const conditions = [];
+        // Handle raw WHERE clause
+        if (options.rawWhere) {
+            return { sql: options.rawWhere, values: [] };
+        }
+        // Build WHERE conditions from filters
+        for (const filter of options.filters) {
+            const { field, operator, value } = filter;
+            switch (operator) {
+                case '=':
+                case '>':
+                case '<':
+                case '>=':
+                case '<=':
+                case '!=':
+                    conditions.push(`"${field}" ${operator} ?`);
+                    values.push(value);
+                    break;
+                case 'LIKE':
+                    conditions.push(`"${field}" LIKE ?`);
+                    values.push(value);
+                    break;
+                case 'IN':
+                    const placeholders = Array.isArray(value) ? value.map(() => '?').join(', ') : '?';
+                    conditions.push(`"${field}" IN (${placeholders})`);
+                    if (Array.isArray(value)) {
+                        values.push(...value);
+                    }
+                    else {
+                        values.push(value);
+                    }
+                    break;
+                default:
+                    conditions.push(`"${field}" = ?`);
+                    values.push(value);
+            }
+        }
+        const sql = conditions.length > 0 ? conditions.join(' AND ') : '';
+        return { sql, values };
+    }
+    async get(options) {
+        const fields = options.fields && options.fields.length > 0
+            ? options.fields.map(f => `"${f}"`).join(', ')
+            : '*';
+        let sql = `SELECT ${fields} FROM "${options.collectionName}"`;
+        const values = [];
+        // Add WHERE clause
+        const { sql: whereSql, values: whereValues } = this.buildWhereClause(options);
+        if (whereSql) {
+            sql += ` WHERE ${whereSql}`;
+            values.push(...whereValues);
+        }
+        // Add ORDER BY
+        if (options.sortBy) {
+            sql += ` ORDER BY "${options.sortBy.field}" ${options.sortBy.direction.toUpperCase()}`;
+        }
+        // Add LIMIT and OFFSET
+        if (options.limit !== null) {
+            sql += ` LIMIT ?`;
+            values.push(options.limit);
+        }
+        if (options.offset !== null) {
+            sql += ` OFFSET ?`;
+            values.push(options.offset);
+        }
+        return this.all(sql, values);
+    }
+    async getOne(options) {
+        const results = await this.get({ ...options, limit: 1 });
+        return results[0] || null;
+    }
+    async getDocuments(options) {
+        return this.get(options);
+    }
+    async addDocument(collectionName, data) {
+        const fields = Object.keys(data);
+        const placeholders = fields.map(() => '?').join(', ');
+        const values = Object.values(data);
+        const sql = `INSERT INTO "${collectionName}" (${fields.map(f => `"${f}"`).join(', ')}) VALUES (${placeholders})`;
+        const result = await this.run(sql, values);
+        return String(result.lastID);
+    }
+    async updateDocument(collectionName, docId, data) {
+        const fields = Object.keys(data);
+        const setClause = fields.map(f => `"${f}" = ?`).join(', ');
+        const values = [...Object.values(data), docId];
+        const sql = `UPDATE "${collectionName}" SET ${setClause} WHERE id = ?`;
+        await this.run(sql, values);
+    }
+    async deleteDocument(collectionName, docId) {
+        const sql = `DELETE FROM "${collectionName}" WHERE id = ?`;
+        await this.run(sql, [docId]);
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.db.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    /**
+     * Execute a raw SQL query
+     */
+    async raw(sql, values) {
+        if (sql.trim().toUpperCase().startsWith('SELECT')) {
+            return this.all(sql, values || []);
+        }
+        else {
+            return this.run(sql, values || []);
+        }
+    }
+}
+/**
+ * Factory function to create SQLite adapter
+ */
+export function createSQLiteAdapter(config) {
+    return new SQLiteAdapter(config);
+}

package/dist/cli/create-connection.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/create-connection.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+const args = process.argv.slice(2);
+const connectionName = args[0];
+const type = args[1] || 'api';
+if (!connectionName) {
+    console.error('Usage: npm run create-connection <connectionName> [type]');
+    process.exit(1);
+}
+const connectionDir = path.resolve(process.cwd(), 'src/connection');
+if (!fs.existsSync(connectionDir))
+    fs.mkdirSync(connectionDir, { recursive: true });
+const filePath = path.join(connectionDir, `${connectionName}.ts`);
+let configTemplate = '';
+if (type === 'mysql') {
+    configTemplate = `
+    type: 'mysql',
+    host: 'localhost',
+    port: 3306,
+    user: 'root',
+    password: '',
+    database: '${connectionName}'
+`;
+}
+else if (type === 'sqlite') {
+    configTemplate = `
+    type: 'sqlite',
+    filename: './${connectionName}.db'
+`;
+}
+else {
+    configTemplate = `
+    type: '${type}',
+    // Add configuration here
+`;
+}
+const fileContent = `import { ConnectionConfig } from '@neupgroup/mapper';
+
+export const config: ConnectionConfig = {
+${configTemplate}
+};
+`;
+fs.writeFileSync(filePath, fileContent.trim());
+console.log(`Created connection file: ${filePath} `);

package/dist/cli/create-migration.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/create-migration.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+const args = process.argv.slice(2);
+const tableName = args[0];
+const remarks = args[1] || '';
+if (!tableName) {
+    console.error('Usage: npm run create-migration <tableName> [remarks]');
+    process.exit(1);
+}
+// Ensure directories exist
+const migrationDir = path.resolve(process.cwd(), 'src/migration');
+const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+if (!fs.existsSync(migrationDir))
+    fs.mkdirSync(migrationDir, { recursive: true });
+if (!fs.existsSync(schemasDir))
+    fs.mkdirSync(schemasDir, { recursive: true });
+// Generate timestamp
+const now = new Date();
+const timestamp = now.toISOString().replace(/[-:T.]/g, '').slice(0, 14); // YYYYMMDDHHMMSS format roughly
+// Actually better manual format: YYYYMMDD_HHMMSS
+const pad = (n) => n.toString().padStart(2, '0');
+const tsResult = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+const fileName = `${tsResult}_${tableName}${remarks ? '_' + remarks : ''}.ts`;
+const filePath = path.join(migrationDir, fileName);
+const fileContent = `
+import { Mapper, TableMigrator } from '@neupgroup/mapper';
+
+export async function up() {
+    // const table = Mapper.schemas().table('${tableName}');
+    // table.addColumn('id').type('int').isPrimary().autoIncrement().exec();
+    // ... add more columns
+    console.log('Migrating up: ${tableName}');
+}
+
+export async function down() {
+    // Drop table or revert changes
+    console.log('Migrating down: ${tableName}');
+}
+`;
+fs.writeFileSync(filePath, fileContent.trim());
+console.log(`Created migration file: ${filePath}`);
+// Create or update schema definition
+const schemaFilePath = path.join(schemasDir, `${tableName}.ts`);
+if (!fs.existsSync(schemaFilePath)) {
+    const schemaContent = `
+export const ${tableName} = {
+    fields: [
+        // { name: 'id', type: 'int', isPrimary: true, autoIncrement: true }
+    ],
+    insertableFields: [],
+    updatableFields: [],
+    massUpdateable: false,
+    massDeletable: false,
+    usesConnection: 'default' // Update this
+};
+`;
+    fs.writeFileSync(schemaFilePath, schemaContent.trim());
+    console.log(`Created schema definition: ${schemaFilePath}`);
+}
+else {
+    console.log(`Schema file already exists: ${schemaFilePath}`);
+}

package/dist/docs.d.ts

@@ -1,3 +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 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  sqlite_local: {\n    type: sqlite\n    filename: \"./data.db\"\n  }\n]\n```\n\nNotes:\n- `type` (or `dbType`) defaults to `api` if omitted.\n- For SQLite, use `filename` to specify the path to the database file.\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## Fluent API Requests\n\nFor API connections, you can make fluent HTTP requests without defining a full schema.\n\n```ts\nconst conn = Mapper.connection({ type: 'api', url: 'https://api.example.com' });\n\n// Simple POST\nawait conn.path(\"/users\").post({ name: 'John Doe' });\n\n// Chained paths and headers\nconst result = await conn.path(\"/v1\")\n  .path(\"/users/123\")\n  .header(\"Authorization\", \"Bearer my-token\")\n  .headers({ \"X-Custom\": \"value\" })\n  .get();\n\n// Support for multiple values for the same header\nawait conn.path(\"/notify\")\n  .header(\"X-Tag\", \"news\")\n  .header(\"X-Tag\", \"alerts\")\n  .post({ body: \"Hello\" });\n```\n\nAvailable methods: `.get()`, `.post(data)`, `.put(data)`, `.patch(data)`, `.delete()`.\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

@@ -65,11 +65,17 @@ connections = [
     baseUrl: "https://api.example.com"
     token: "abc123"
   }
+
+  sqlite_local: {
+    type: sqlite
+    filename: "./data.db"
+  }
 ]
 \`\`\`
 
 Notes:
 - \`type\` (or \`dbType\`) defaults to \`api\` if omitted.
+- For SQLite, use \`filename\` to specify the path to the database file.
 - Values can be unquoted or quoted; comments using \`#\` are ignored.
 
 Parse and normalize:
@@ -190,6 +196,34 @@ const many = await User.where('email', '%@example.com', 'like').get()
 
 ---
 
+## Fluent API Requests
+
+For API connections, you can make fluent HTTP requests without defining a full schema.
+
+\`\`\`ts
+const conn = Mapper.connection({ type: 'api', url: 'https://api.example.com' });
+
+// Simple POST
+await conn.path("/users").post({ name: 'John Doe' });
+
+// Chained paths and headers
+const result = await conn.path("/v1")
+  .path("/users/123")
+  .header("Authorization", "Bearer my-token")
+  .headers({ "X-Custom": "value" })
+  .get();
+
+// Support for multiple values for the same header
+await conn.path("/notify")
+  .header("X-Tag", "news")
+  .header("X-Tag", "alerts")
+  .post({ body: "Hello" });
+\`\`\`
+
+Available methods: \`.get()\`, \`.post(data)\`, \`.put(data)\`, \`.patch(data)\`, \`.delete()\`.
+
+---
+
 ## Schema Configuration Details
 
 - \`primary\`: marks primary key; used for updates/deletes.

package/dist/fluent-mapper.d.ts

@@ -1,4 +1,5 @@
 import { SchemaManager } from './index.js';
+import { TableMigrator } from './migrator.js';
 export declare class FluentQueryBuilder {
     private mapper;
     private schemaName;
@@ -48,6 +49,22 @@ export declare class FluentSchemaCollectionBuilder {
         [key: string]: any;
     }>): FluentMapper;
 }
+export declare class FluentApiRequestBuilder {
+    private mapper;
+    private connectionName;
+    private _path;
+    private _headers;
+    constructor(mapper: any, connectionName: string, path?: string);
+    path(p: string): this;
+    header(key: string | Record<string, string | string[]>, value?: string | string[]): this;
+    headers(h: Record<string, string | string[]> | any[]): this;
+    get(): Promise<any>;
+    post(data?: any): Promise<any>;
+    put(data?: any): Promise<any>;
+    patch(data?: any): Promise<any>;
+    delete(): Promise<any>;
+    private execute;
+}
 export declare class FluentConnectionSelector {
     private mapper;
     private connectionName;
@@ -57,15 +74,23 @@ export declare class FluentConnectionSelector {
     table(tableName: string): FluentQueryBuilder;
     collection(collectionName: string): FluentQueryBuilder;
     schemas(schemaName: string): FluentSchemaWrapper;
+    path(path: string): FluentApiRequestBuilder;
+    header(key: string | Record<string, string | string[]>, value?: string | string[]): FluentApiRequestBuilder;
+    headers(headers: Record<string, string> | any[]): FluentApiRequestBuilder;
+    get(): Promise<any>;
+    post(data?: any): Promise<any>;
+    put(data?: any): Promise<any>;
+    patch(data?: any): Promise<any>;
+    delete(): Promise<any>;
 }
 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;
+    makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
     connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
-    makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', 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>;
@@ -75,12 +100,12 @@ export declare class FluentMapper {
 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 makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    static makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
+    static makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
     static query(schemaName: string): FluentQueryBuilder;
     static connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
     static useConnection(connectionName: string): FluentConnectionSelector;
-    static schemas(name: string): FluentSchemaWrapper;
+    static schemas(name?: string): FluentSchemaWrapper | SchemaManagerWrapper;
     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>;
@@ -106,3 +131,8 @@ export declare class FluentSchemaWrapper {
     offset(n: number): FluentQueryBuilder;
     insert(data: Record<string, any>): Promise<any>;
 }
+export declare class SchemaManagerWrapper {
+    private manager;
+    constructor(manager: SchemaManager);
+    table(name: string): TableMigrator;
+}

package/dist/fluent-mapper.js

@@ -1,4 +1,5 @@
 import { createMapper } from './mapper.js';
+import { TableMigrator } from './migrator.js';
 export class FluentQueryBuilder {
     constructor(mapper, schemaName) {
         this.mapper = mapper;
@@ -109,6 +110,80 @@ export class FluentSchemaCollectionBuilder {
         return new FluentMapper(this.mapper);
     }
 }
+export class FluentApiRequestBuilder {
+    constructor(mapper, connectionName, path = '') {
+        this.mapper = mapper;
+        this.connectionName = connectionName;
+        this._path = '';
+        this._headers = {};
+        this._path = path;
+    }
+    path(p) {
+        if (this._path === '') {
+            this._path = p;
+        }
+        else {
+            if (!p.startsWith('/') && !this._path.endsWith('/')) {
+                this._path += '/';
+            }
+            this._path += p;
+        }
+        return this;
+    }
+    header(key, value) {
+        if (typeof key === 'object') {
+            Object.entries(key).forEach(([k, v]) => this.header(k, v));
+        }
+        else if (value !== undefined) {
+            if (this._headers[key]) {
+                const existing = this._headers[key];
+                if (Array.isArray(existing)) {
+                    if (Array.isArray(value)) {
+                        existing.push(...value);
+                    }
+                    else {
+                        existing.push(value);
+                    }
+                }
+                else {
+                    this._headers[key] = [existing, ...(Array.isArray(value) ? value : [value])];
+                }
+            }
+            else {
+                this._headers[key] = value;
+            }
+        }
+        else {
+            // Check for "Key: Value" string
+            if (key.includes(':')) {
+                const [k, ...v] = key.split(':');
+                this.header(k.trim(), v.join(':').trim());
+            }
+        }
+        return this;
+    }
+    headers(h) {
+        if (Array.isArray(h)) {
+            h.forEach(item => this.header(item));
+        }
+        else {
+            this.header(h);
+        }
+        return this;
+    }
+    async get() { return this.execute('GET'); }
+    async post(data) { return this.execute('POST', data); }
+    async put(data) { return this.execute('PUT', data); }
+    async patch(data) { return this.execute('PATCH', data); }
+    async delete() { return this.execute('DELETE'); }
+    async execute(method, data) {
+        const adapter = this.mapper.getConnections().getAdapter(this.connectionName);
+        if (!adapter || typeof adapter.request !== 'function') {
+            throw new Error(`Connection "${this.connectionName}" does not support custom requests.`);
+        }
+        return adapter.request(method, this._path, data, this._headers);
+    }
+}
 export class FluentConnectionSelector {
     constructor(mapper, connectionName) {
         this.mapper = mapper;
@@ -129,6 +204,31 @@ export class FluentConnectionSelector {
     schemas(schemaName) {
         return new FluentSchemaWrapper(this.mapper.getSchemaManager(), schemaName, this.connectionName);
     }
+    // API Request methods
+    path(path) {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName, path);
+    }
+    header(key, value) {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).header(key, value);
+    }
+    headers(headers) {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).headers(headers);
+    }
+    get() {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).get();
+    }
+    post(data) {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).post(data);
+    }
+    put(data) {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).put(data);
+    }
+    patch(data) {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).patch(data);
+    }
+    delete() {
+        return new FluentApiRequestBuilder(this.mapper, this.connectionName).delete();
+    }
 }
 export class FluentMapper {
     constructor(mapper) {
@@ -209,8 +309,10 @@ export class StaticMapper {
         return StaticMapper.connection(connectionName);
     }
     static schemas(name) {
-        return new FluentSchemaWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager(), // Access underlying manager
-        name);
+        if (name) {
+            return new FluentSchemaWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager(), name);
+        }
+        return new SchemaManagerWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager());
     }
     // Direct static methods
     static async get(schemaName, filters) {
@@ -321,3 +423,12 @@ export class FluentSchemaWrapper {
 // It is NOT exported. I need to export it or duplicate logic.
 // I'll export it from index.ts.
 import { parseDescriptorStructure } from './index.js'; // fixed import at bottom
+export class SchemaManagerWrapper {
+    constructor(manager) {
+        this.manager = manager;
+    }
+    table(name) {
+        // This allows Mapper.schemas().table('name') to return a migrator
+        return new TableMigrator(name);
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter, QueryOptions } from './orm/index.js';
 export type ColumnType = 'string' | 'number' | 'boolean' | 'date' | 'int';
-export type ConnectionType = 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api';
+export type ConnectionType = 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite';
 export interface Field {
     name: string;
     type: ColumnType;
@@ -135,3 +135,4 @@ export { MySQLAdapter, createMySQLAdapter, PostgreSQLAdapter, createPostgreSQLAd
 export type { MySQLConfig, PostgreSQLConfig, MongoDBConfig, APIAdapterConfig, AdapterConfig } from './adapters/index.js';
 export { MapperError, AdapterMissingError, UpdatePayloadMissingError, DocumentMissingIdError, ConnectionExistingError, ConnectionUnknownError, SchemaExistingError, SchemaMissingError, SchemaConfigurationError, } from './errors.js';
 export { Connector, mapper } from './connector.js';
+export { TableMigrator, ColumnBuilder } from './migrator.js';

package/dist/index.js

@@ -404,3 +404,4 @@ export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, c
 export { MySQLAdapter, createMySQLAdapter, PostgreSQLAdapter, createPostgreSQLAdapter, MongoDBAdapter, createMongoDBAdapter, APIAdapter, createAPIAdapter, createAdapter, createAdapterFromUrl, autoAttachAdapter } from './adapters/index.js';
 export { MapperError, AdapterMissingError, UpdatePayloadMissingError, DocumentMissingIdError, ConnectionExistingError, ConnectionUnknownError, SchemaExistingError, SchemaMissingError, SchemaConfigurationError, } from './errors.js';
 export { Connector, mapper } from './connector.js';
+export { TableMigrator, ColumnBuilder } from './migrator.js';

package/dist/mapper.d.ts

@@ -12,7 +12,7 @@ export declare class Mapper {
     private applyConfig;
     private applyDefaultConfig;
     private createSchema;
-    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): this;
+    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', 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>[]>;

package/dist/mapper.js

@@ -1,4 +1,5 @@
 import { Connections, SchemaManager } from './index.js';
+import { autoAttachAdapter } from './adapters/index.js';
 export class Mapper {
     constructor() {
         this.configured = false;
@@ -57,6 +58,8 @@ export class Mapper {
             return 'mongodb';
         if (url.includes('firestore'))
             return 'firestore';
+        if (url.includes('sqlite') || url.endsWith('.db') || url.endsWith('.sqlite'))
+            return 'sqlite';
         return 'api';
     }
     applyConfig(config) {
@@ -86,6 +89,7 @@ export class Mapper {
     // Simplified API methods
     connect(name, type, config) {
         this.connections.create(name, type).key(config);
+        autoAttachAdapter(this.connections, name, type, config);
         return this;
     }
     schema(name) {

package/dist/migrator.d.ts

@@ -0,0 +1,22 @@
+export type ColumnType = 'string' | 'number' | 'boolean' | 'date' | 'int';
+export declare class ColumnBuilder {
+    private name;
+    private def;
+    constructor(name: string);
+    type(t: ColumnType | string): this;
+    isPrimary(): this;
+    isUnique(): this;
+    notNull(): this;
+    autoIncrement(): this;
+    default(val: any): this;
+    values(vals: any[]): this;
+    foreignKey(table: string, column: string): this;
+    exec(): Promise<void>;
+    getDefinition(): any;
+}
+export declare class TableMigrator {
+    private name;
+    private columns;
+    constructor(name: string);
+    addColumn(name: string): ColumnBuilder;
+}

package/dist/migrator.js

@@ -0,0 +1,65 @@
+export class ColumnBuilder {
+    constructor(name) {
+        this.name = name;
+        this.def = {
+            type: 'string',
+            isPrimary: false,
+            isUnique: false,
+            notNull: false,
+            autoIncrement: false,
+            defaultValue: undefined,
+            enumValues: [],
+            foreignKey: null
+        };
+        this.def.name = name;
+    }
+    type(t) {
+        this.def.type = t;
+        return this;
+    }
+    isPrimary() {
+        this.def.isPrimary = true;
+        return this;
+    }
+    isUnique() {
+        this.def.isUnique = true;
+        return this;
+    }
+    notNull() {
+        this.def.notNull = true;
+        return this;
+    }
+    autoIncrement() {
+        this.def.autoIncrement = true;
+        return this;
+    }
+    default(val) {
+        this.def.defaultValue = val;
+        return this;
+    }
+    values(vals) {
+        this.def.enumValues = vals;
+        return this;
+    }
+    foreignKey(table, column) {
+        this.def.foreignKey = { table, column };
+        return this;
+    }
+    async exec() {
+        return Promise.resolve();
+    }
+    getDefinition() {
+        return this.def;
+    }
+}
+export class TableMigrator {
+    constructor(name) {
+        this.name = name;
+        this.columns = [];
+    }
+    addColumn(name) {
+        const col = new ColumnBuilder(name);
+        this.columns.push(col);
+        return col;
+    }
+}

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "create-migration": "dist/cli/create-migration.js",
+    "create-connection": "dist/cli/create-connection.js"
+  },
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "tsc -p ./tsconfig.json"
+    "build": "tsc -p ./tsconfig.json",
+    "create-migration": "npx tsx src/cli/create-migration.ts",
+    "create-connection": "npx tsx src/cli/create-connection.ts"
   },
   "publishConfig": {
     "access": "public"