@neupgroup/mapper 1.1.0 → 1.2.0

package/README.md

@@ -1,221 +1,37 @@
-# Neup.Mapper (Library)
-
-Neup.Mapper is a small, framework-agnostic TypeScript library that provides:
-
-- Database connectivity via an adapter pattern (bring your own driver)
-- HTTP API access via an adapter pattern (bring your own client)
-- A simple config/registry to define multiple named connections ("maps")
-
-## Install
-
-```
-npm install @neupgroup/mapper
-```
-
-If you’re working locally on the source:
-
-```
-npm install
-npm run build
-```
-
-Artifacts (`*.js`, `*.d.ts`) are emitted into the project root.
-
-## Quick Start (Adapter Basics)
-
-### Database
-
-```
-import { createDb, IDbAdapter } from "@neupgroup/mapper";
-
-const adapter: IDbAdapter = {
-  async connect(config) {
-    // initialize your driver, e.g., pg, mysql2, sqlite, etc.
-  },
-  async query(sql, params) {
-    // delegate to your driver
-    return [];
-  },
-  async close() {
-    // close driver resources
-  },
-};
-
-const db = createDb(adapter);
-await db.connect({ host: "localhost" });
-const rows = await db.query("SELECT 1");
-await db.close();
-```
-
-### API
-
-```
-import { createApiClient, IApiAdapter } from "@neupgroup/mapper";
-
-const http: IApiAdapter = {
-  async request(req) {
-    // use fetch/axios/undici, return { status, headers, data }
-    return { status: 200, data: { ok: true } };
-  },
-};
-
-const api = createApiClient("https://api.example.com", http, { Authorization: "Bearer token" });
-const res = await api.get("/users");
-```
-
-## Config & Registry (Multiple Named Maps)
-
-You can define multiple named connections (maps), similar to Firebase/Laravel style configs, and then refer to them in your application.
-
-Create a `mapper.config.ts` in your app:
-
-```
-// mapper.config.ts
-import { defineConfig, IApiAdapter, IDbAdapter } from "@neupgroup/mapper";
-
-// Provide your concrete adapters
-const http: IApiAdapter = {
-  async request(req) {
-    // Make HTTP requests using fetch/axios and return { status, headers, data }
-    return { status: 200, data: { ok: true } };
-  },
-};
-
-const dbAdapter: IDbAdapter = {
-  async connect(config) {
-    // Initialize DB driver with credentials from config
-  },
-  async query(sql, params) {
-    return [];
-  },
-  async close() {},
-};
-
-export default defineConfig({
-  maps: [
-    {
-      kind: "api",
-      name: "core",
-      baseUrl: "https://api.example.com",
-      defaultHeaders: { Authorization: "Bearer <token>" },
-      adapter: http,
-    },
-    {
-      kind: "db",
-      name: "analytics",
-      connection: { host: "db.local", user: "app", password: "secret" },
-      adapter: dbAdapter,
-    },
-  ],
-});
-```
-
-Use the registry in your app code:
-
-```
-import config from "./mapper.config";
-import { loadConfig } from "@neupgroup/mapper";
-
-const maps = loadConfig(config);
-
-// Use API
-const api = maps.api("core");
-const res = await api.get("/users");
-
-// Use DB
-const db = maps.db("analytics");
-await db.connect({ host: "db.local" });
-const rows = await db.query("SELECT * FROM events WHERE kind = ?", ["click"]);
-await db.close();
-
-// Introspection
-maps.list(); // [{ name: "core", kind: "api" }, { name: "analytics", kind: "db" }]
-```
-
-## Global `mapper()` API (No App Init)
-
-If you prefer a PHP‑style fluent syntax without explicit app initialization, use the global `mapper()` function:
-
-### Access existing maps (registered via config)
-
-```
-import appConfig from './mapper.config';
-import { useConfig, mapper } from '@neupgroup/mapper';
-
-// Register once (e.g., at app entry) — then use anywhere
-useConfig(appConfig);
-
-// DB usage
-const usersTable = mapper('analytics').table('users');
-const allUsers = await usersTable.selectAll();
-const activeUsers = await usersTable.query('WHERE status = ?', ['active']);
-
-// API usage
-const usersEndpoint = mapper('core').path('/users');
-const res = await usersEndpoint.get();
-```
-
-### Create ephemeral maps with chaining
-
-```
-import { mapper } from '@neupgroup/mapper';
-import type { IDbAdapter, IApiAdapter } from '@neupgroup/mapper';
-
-const dbAdapter: IDbAdapter = { /* implement connect/query/close */ };
-const httpAdapter: IApiAdapter = { /* implement request */ };
-
-// Create and register a DB map
-mapper()
-  .create('tempDb', 'db')
-  .host('localhost')
-  .dbname('app')
-  .user('user')
-  .pass('secret')
-  .adapter(dbAdapter)
-  .save();
-
-// Use it anywhere
-const t = mapper('tempDb').table('logs');
-const rows = await t.query('WHERE level = ?', ['error']);
-
-// Create and register an API map
-mapper()
-  .create('tempApi', 'api')
-  .baseUrl('https://api.example.com')
-  .header('Authorization', 'Bearer token')
-  .adapter(httpAdapter)
-  .save();
-
-const endpoint = mapper('tempApi').path('/events');
-await endpoint.post({ type: 'click' });
-```
-
-Notes:
-- `mapper('name').table('...')` is for DB maps; `mapper('name').path('...')` is for API maps.
-- Duplicate map names are prevented; attempting to re‑use a name throws a clear error.
-- The builder requires `create(name, kind)` and `adapter(...)` before `save()`.
-
-### Notes
-
-- The registry does not auto-connect databases; call `db.connect()` when appropriate.
-- The API client merges `defaultHeaders` with any per-call headers.
-- Each map is keyed by a unique `name`; use `maps.get(name)` if you don’t know the type at compile time.
-
-## API Reference
-
-- `createDb(adapter: IDbAdapter): Db`
-- `createApiClient(baseUrl: string, adapter: IApiAdapter, defaultHeaders?: Record<string,string>): ApiClient`
-- `defineConfig(config: MapperConfig): MapperConfig`
-- `createRegistry(config: MapperConfig): MapperRegistry`
-- `loadConfig(config: MapperConfig): MapperRegistry` (alias)
-
-## Publish
-
-This package is configured for public publish (scoped):
-
-```
-npm run build
-npm publish --access public
-```
-
-Ensure your `package.json` has `"private": false` and `"publishConfig": { "access": "public" }`.
+# @neupgroup/mapper
+
+Core library for Neup.Mapper. Provides simple schema registration utilities that can be expanded over time.
+
+## Install
+
+```bash
+npm install @neupgroup/mapper
+```
+
+## Usage
+
+```ts
+import Mapper from '@neupgroup/mapper';
+
+const mapper = new Mapper();
+
+mapper.register({
+  name: 'User',
+  fields: [
+    { name: 'id', type: 'string' },
+    { name: 'email', type: 'string' },
+    { name: 'createdAt', type: 'date' },
+  ],
+});
+
+console.log(mapper.list());
+```
+
+## Build
+
+```bash
+npx tsc -p ./tsconfig.json
+```
+
+Outputs are generated to `dist/` with type declarations.
+

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,46 @@
+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);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+import type { DbAdapter, QueryOptions } from './orm';
+export type ColumnType = 'string' | 'number' | 'boolean' | 'date' | 'int';
+export type ConnectionType = 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api';
+export interface Field {
+    name: string;
+    type: ColumnType;
+    editable?: boolean;
+    autoIncrement?: boolean;
+    nullable?: boolean;
+    defaultValue?: unknown;
+}
+export interface SchemaDef {
+    name: string;
+    connectionName: string;
+    collectionName: string;
+    fields: Field[];
+    allowUndefinedFields?: boolean;
+}
+interface ConnectionConfig {
+    name: string;
+    type: ConnectionType;
+    key: Record<string, any>;
+}
+declare class ConnectionBuilder {
+    private manager;
+    private name;
+    private type;
+    constructor(manager: Connections, name: string, type: ConnectionType);
+    key(config: Record<string, any>): Connections;
+}
+export declare class Connections {
+    private connections;
+    private adapters;
+    create(name: string, type: ConnectionType): ConnectionBuilder;
+    register(config: ConnectionConfig): this;
+    attachAdapter(name: string, adapter: DbAdapter): this;
+    get(name: string): ConnectionConfig | undefined;
+    getAdapter(name: string): DbAdapter | undefined;
+    list(): ConnectionConfig[];
+}
+declare class SchemaBuilder {
+    private manager;
+    private name;
+    private connectionName?;
+    private collectionName?;
+    private fields;
+    private allowUndefinedFields;
+    constructor(manager: SchemaManager, name: string);
+    use(options: {
+        connection: string;
+        collection: string;
+    }): this;
+    setStructure(structure: Record<string, string> | Field[]): SchemaManager;
+}
+declare class SchemaQuery {
+    private manager;
+    private def;
+    private filters;
+    private rawWhere;
+    private pendingUpdate;
+    constructor(manager: SchemaManager, def: SchemaDef);
+    where(fieldOrPair: string | [string, any], value?: any, operator?: string): this;
+    whereComplex(raw: string): this;
+    private buildOptions;
+    to(update: Record<string, any>): this;
+    get(): Promise<Record<string, any>[]>;
+    getOne(): Promise<Record<string, any> | null>;
+    add(data: Record<string, any>): Promise<string>;
+    delete(): Promise<void>;
+    deleteOne(): Promise<void>;
+    update(): Promise<void>;
+    updateOne(): Promise<void>;
+}
+export declare class SchemaManager {
+    private connections;
+    private schemas;
+    constructor(connections: Connections);
+    create(name: string): SchemaBuilder;
+    register(def: SchemaDef): this;
+    use(name: string): SchemaQuery;
+    getAdapter(connectionName: string): DbAdapter | undefined;
+    list(): SchemaDef[];
+}
+export declare function connection(): Connections;
+export declare function schema(conns?: Connections): SchemaManager;
+export declare const schemas: SchemaManager;
+export { createOrm } from './orm';
+export type { DbAdapter, QueryOptions };

package/dist/index.js

@@ -0,0 +1,278 @@
+class AdapterRegistry {
+    constructor() {
+        this.adaptersByConnection = new Map();
+    }
+    attach(connectionName, adapter) {
+        this.adaptersByConnection.set(connectionName, adapter);
+    }
+    get(connectionName) {
+        return this.adaptersByConnection.get(connectionName);
+    }
+}
+class ConnectionBuilder {
+    constructor(manager, name, type) {
+        this.manager = manager;
+        this.name = name;
+        this.type = type;
+    }
+    key(config) {
+        this.manager.register({ name: this.name, type: this.type, key: config });
+        return this.manager;
+    }
+}
+export class Connections {
+    constructor() {
+        this.connections = new Map();
+        this.adapters = new AdapterRegistry();
+    }
+    create(name, type) {
+        if (this.connections.has(name)) {
+            throw new Error(`Connection with name '${name}' already exists`);
+        }
+        return new ConnectionBuilder(this, name, type);
+    }
+    register(config) {
+        if (this.connections.has(config.name)) {
+            throw new Error(`Connection with name '${config.name}' already exists`);
+        }
+        this.connections.set(config.name, config);
+        return this;
+    }
+    attachAdapter(name, adapter) {
+        if (!this.connections.has(name)) {
+            throw new Error(`Cannot attach adapter: unknown connection '${name}'`);
+        }
+        this.adapters.attach(name, adapter);
+        return this;
+    }
+    get(name) {
+        return this.connections.get(name);
+    }
+    getAdapter(name) {
+        return this.adapters.get(name);
+    }
+    list() {
+        return Array.from(this.connections.values());
+    }
+}
+function parseDescriptorStructure(struct) {
+    let allowUndefinedFields = false;
+    const fields = [];
+    for (const [key, descriptor] of Object.entries(struct)) {
+        if (key === '?field') {
+            // Presence of '?field' enables accepting fields not defined in the schema
+            allowUndefinedFields = true;
+            continue;
+        }
+        const tokens = descriptor.split(/\s+/).map(t => t.trim().toLowerCase()).filter(Boolean);
+        const field = {
+            name: key,
+            type: tokens.find(t => ['string', 'number', 'boolean', 'date', 'int'].includes(t)) || 'string',
+            editable: tokens.includes('editable'),
+            autoIncrement: tokens.includes('auto_increment') || tokens.includes('autoincrement'),
+        };
+        fields.push(field);
+    }
+    return { fields, allowUndefinedFields };
+}
+class SchemaBuilder {
+    constructor(manager, name) {
+        this.manager = manager;
+        this.name = name;
+        this.fields = [];
+        this.allowUndefinedFields = false;
+    }
+    use(options) {
+        this.connectionName = options.connection;
+        this.collectionName = options.collection;
+        return this;
+    }
+    setStructure(structure) {
+        if (Array.isArray(structure)) {
+            this.fields = structure;
+            this.allowUndefinedFields = false;
+        }
+        else {
+            const parsed = parseDescriptorStructure(structure);
+            this.fields = parsed.fields;
+            this.allowUndefinedFields = parsed.allowUndefinedFields;
+        }
+        // Finalize schema registration
+        if (!this.connectionName || !this.collectionName) {
+            throw new Error('Schema.use({ connection, collection }) must be set before setStructure');
+        }
+        this.manager.register({
+            name: this.name,
+            connectionName: this.connectionName,
+            collectionName: this.collectionName,
+            fields: this.fields,
+            allowUndefinedFields: this.allowUndefinedFields,
+        });
+        return this.manager;
+    }
+}
+class SchemaQuery {
+    constructor(manager, def) {
+        this.manager = manager;
+        this.def = def;
+        this.filters = [];
+        this.rawWhere = null;
+        this.pendingUpdate = null;
+    }
+    // where('field','value', operator?) or where([field, value])
+    where(fieldOrPair, value, operator) {
+        if (Array.isArray(fieldOrPair)) {
+            const [field, v] = fieldOrPair;
+            this.filters.push({ field, operator: '=', value: v });
+        }
+        else {
+            const field = fieldOrPair;
+            this.filters.push({ field, operator: operator !== null && operator !== void 0 ? operator : '=', value });
+        }
+        return this;
+    }
+    // Accept a raw complex where clause string
+    whereComplex(raw) {
+        this.rawWhere = raw;
+        return this;
+    }
+    buildOptions() {
+        return {
+            collectionName: this.def.collectionName,
+            filters: this.filters.map(f => ({ field: f.field, operator: f.operator, value: f.value })),
+            limit: null,
+            offset: null,
+            sortBy: null,
+            fields: this.def.fields.map(f => f.name),
+            rawWhere: this.rawWhere,
+        };
+    }
+    to(update) {
+        this.pendingUpdate = update;
+        return this;
+    }
+    async get() {
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        const options = this.buildOptions();
+        const docs = adapter.get ? await adapter.get(options) : await adapter.getDocuments(options);
+        return docs;
+    }
+    async getOne() {
+        var _a;
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        const options = this.buildOptions();
+        if (adapter.getOne) {
+            const one = await adapter.getOne(options);
+            return (_a = one) !== null && _a !== void 0 ? _a : null;
+        }
+        const results = adapter.get ? await adapter.get(options) : await adapter.getDocuments(options);
+        return results[0] || null;
+    }
+    async add(data) {
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        if (!this.def.allowUndefinedFields) {
+            const allowed = new Set(this.def.fields.map(f => f.name));
+            data = Object.fromEntries(Object.entries(data).filter(([k]) => allowed.has(k)));
+        }
+        return adapter.addDocument(this.def.collectionName, data);
+    }
+    async delete() {
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        const docs = await this.get();
+        // Expect each doc has an 'id' field
+        for (const d of docs) {
+            const id = d.id;
+            if (!id)
+                throw new Error('Document missing id; cannot delete');
+            await adapter.deleteDocument(this.def.collectionName, id);
+        }
+    }
+    async deleteOne() {
+        const one = await this.getOne();
+        if (!one)
+            return;
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        const id = one.id;
+        if (!id)
+            throw new Error('Document missing id; cannot deleteOne');
+        await adapter.deleteDocument(this.def.collectionName, id);
+    }
+    async update() {
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        if (!this.pendingUpdate)
+            throw new Error('No update payload set; call to({ ... }) first');
+        const docs = await this.get();
+        for (const d of docs) {
+            const id = d.id;
+            if (!id)
+                throw new Error('Document missing id; cannot update');
+            await adapter.updateDocument(this.def.collectionName, id, this.pendingUpdate);
+        }
+    }
+    async updateOne() {
+        const adapter = this.manager.getAdapter(this.def.connectionName);
+        if (!adapter)
+            throw new Error(`No adapter attached for connection '${this.def.connectionName}'`);
+        if (!this.pendingUpdate)
+            throw new Error('No update payload set; call to({ ... }) first');
+        const one = await this.getOne();
+        if (!one)
+            return;
+        const id = one.id;
+        if (!id)
+            throw new Error('Document missing id; cannot updateOne');
+        await adapter.updateDocument(this.def.collectionName, id, this.pendingUpdate);
+    }
+}
+export class SchemaManager {
+    constructor(connections) {
+        this.connections = connections;
+        this.schemas = new Map();
+    }
+    create(name) {
+        if (this.schemas.has(name)) {
+            throw new Error(`Schema with name '${name}' already exists`);
+        }
+        return new SchemaBuilder(this, name);
+    }
+    register(def) {
+        this.schemas.set(def.name, def);
+        return this;
+    }
+    use(name) {
+        const def = this.schemas.get(name);
+        if (!def)
+            throw new Error(`Unknown schema '${name}'`);
+        return new SchemaQuery(this, def);
+    }
+    getAdapter(connectionName) {
+        return this.connections.getAdapter(connectionName);
+    }
+    list() {
+        return Array.from(this.schemas.values());
+    }
+}
+export function connection() {
+    return new Connections();
+}
+export function schema(conns) {
+    const ctx = conns || new Connections();
+    return new SchemaManager(ctx);
+}
+export const schemas = (() => {
+    const conns = new Connections();
+    return new SchemaManager(conns);
+})();
+export { createOrm } from './orm';

package/dist/orm/index.d.ts

@@ -0,0 +1,10 @@
+import type { DbAdapter, QueryOptions } from './types';
+export declare function createOrm(adapter: DbAdapter): {
+    get(options: QueryOptions): Promise<import("@firebase/firestore").DocumentData[]>;
+    getOne(options: QueryOptions): Promise<any>;
+    getDocuments(options: QueryOptions): Promise<import("@firebase/firestore").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>;
+};
+export type { DbAdapter, QueryOptions };

package/dist/orm/index.js

@@ -0,0 +1,28 @@
+export function createOrm(adapter) {
+    return {
+        async get(options) {
+            if (adapter.get)
+                return adapter.get(options);
+            return adapter.getDocuments(options);
+        },
+        async getOne(options) {
+            var _a;
+            if (adapter.getOne)
+                return adapter.getOne(options);
+            const arr = adapter.get ? await adapter.get(options) : await adapter.getDocuments(options);
+            return (_a = arr[0]) !== null && _a !== void 0 ? _a : null;
+        },
+        async getDocuments(options) {
+            return adapter.getDocuments(options);
+        },
+        async addDocument(collectionName, data) {
+            return adapter.addDocument(collectionName, data);
+        },
+        async updateDocument(collectionName, docId, data) {
+            return adapter.updateDocument(collectionName, docId, data);
+        },
+        async deleteDocument(collectionName, docId) {
+            return adapter.deleteDocument(collectionName, docId);
+        },
+    };
+}

package/dist/orm/types.d.ts

@@ -0,0 +1,25 @@
+import type { DocumentData } from 'firebase/firestore';
+export interface QueryOptions {
+    collectionName: string;
+    filters: {
+        field: string;
+        operator: any;
+        value: any;
+    }[];
+    limit: number | null;
+    offset: number | null;
+    sortBy: {
+        field: string;
+        direction: 'asc' | 'desc';
+    } | null;
+    fields: string[];
+    rawWhere?: string | null;
+}
+export interface DbAdapter {
+    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>;
+}

package/dist/orm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,26 +1,20 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.1.0",
-  "private": false,
+  "version": "1.2.0",
+  "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
-    }
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p ./tsconfig.json"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "files": ["*.js", "*.d.ts"],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "typescript": "^5"
   }
 }
+

package/api.d.ts

@@ -1,22 +0,0 @@
-export interface ApiRequest {
-    method: string;
-    url: string;
-    headers?: Record<string, string>;
-    body?: unknown;
-}
-export interface ApiResponse<T = unknown> {
-    status: number;
-    headers?: Record<string, string>;
-    data?: T;
-}
-export interface ApiAdapter {
-    request<T = unknown>(req: ApiRequest): Promise<ApiResponse<T>>;
-}
-export interface ApiClient {
-    get<T = unknown>(path: string, headers?: Record<string, string>): Promise<ApiResponse<T>>;
-    post<T = unknown>(path: string, body?: unknown, headers?: Record<string, string>): Promise<ApiResponse<T>>;
-    put<T = unknown>(path: string, body?: unknown, headers?: Record<string, string>): Promise<ApiResponse<T>>;
-    delete<T = unknown>(path: string, headers?: Record<string, string>): Promise<ApiResponse<T>>;
-}
-export declare function createApiClient(baseUrl: string, adapter: ApiAdapter, defaultHeaders?: Record<string, string>): ApiClient;
-export type { ApiAdapter as IApiAdapter };

package/api.js

@@ -1,14 +0,0 @@
-export function createApiClient(baseUrl, adapter, defaultHeaders) {
-    const buildUrl = (path) => {
-        if (!baseUrl)
-            return path;
-        return baseUrl.endsWith("/") ? `${baseUrl}${path.replace(/^\//, "")}` : `${baseUrl}/${path.replace(/^\//, "")}`;
-    };
-    const mergeHeaders = (headers) => ({ ...(defaultHeaders || {}), ...(headers || {}) });
-    return {
-        get: (path, headers) => adapter.request({ method: "GET", url: buildUrl(path), headers: mergeHeaders(headers) }),
-        post: (path, body, headers) => adapter.request({ method: "POST", url: buildUrl(path), headers: mergeHeaders(headers), body }),
-        put: (path, body, headers) => adapter.request({ method: "PUT", url: buildUrl(path), headers: mergeHeaders(headers), body }),
-        delete: (path, headers) => adapter.request({ method: "DELETE", url: buildUrl(path), headers: mergeHeaders(headers) }),
-    };
-}

package/config.d.ts

@@ -1,39 +0,0 @@
-import { type ApiAdapter, type ApiClient } from "./api";
-import { type DbAdapter, type Db } from "./db";
-export type MapKind = "api" | "db";
-export interface ApiMapConfig {
-    kind: "api";
-    name: string;
-    baseUrl?: string;
-    defaultHeaders?: Record<string, string>;
-    adapter: ApiAdapter;
-}
-export interface DbMapConfig {
-    kind: "db";
-    name: string;
-    connection?: Record<string, unknown>;
-    adapter: DbAdapter;
-}
-export type MapConfig = ApiMapConfig | DbMapConfig;
-export interface MapperConfig {
-    maps: MapConfig[];
-}
-export interface MapperRegistry {
-    /** Get a named API client */
-    api: (name: string) => ApiClient;
-    /** Get a named DB client */
-    db: (name: string) => Db;
-    /** Get any named client (API or DB) */
-    get: (name: string) => ApiClient | Db;
-    /** List registered maps */
-    list: () => {
-        name: string;
-        kind: MapKind;
-    }[];
-}
-/** Helper to define config with proper type inference */
-export declare function defineConfig(config: MapperConfig): MapperConfig;
-/** Create a registry of named API/DB maps from configuration */
-export declare function createRegistry(config: MapperConfig): MapperRegistry;
-/** alias */
-export declare const loadConfig: typeof createRegistry;

package/config.js

@@ -1,49 +0,0 @@
-import { createApiClient } from "./api";
-import { createDb } from "./db";
-/** Helper to define config with proper type inference */
-export function defineConfig(config) {
-    return config;
-}
-/** Create a registry of named API/DB maps from configuration */
-export function createRegistry(config) {
-    const entries = new Map();
-    for (const m of config.maps) {
-        if (!m.name)
-            throw new Error("Map config requires a unique 'name'");
-        if (entries.has(m.name))
-            throw new Error(`Duplicate map name '${m.name}'`);
-        if (m.kind === "api") {
-            const client = createApiClient(m.baseUrl ?? "", m.adapter, m.defaultHeaders);
-            entries.set(m.name, { kind: "api", value: client });
-        }
-        else if (m.kind === "db") {
-            const db = createDb(m.adapter);
-            // Optional: pre-connect using provided connection config.
-            // Consumers may choose to call db.connect() themselves.
-            // if (m.connection) await db.connect(m.connection);
-            entries.set(m.name, { kind: "db", value: db });
-        }
-    }
-    const getApi = (name) => {
-        const entry = entries.get(name);
-        if (!entry || entry.kind !== "api")
-            throw new Error(`API map '${name}' not found`);
-        return entry.value;
-    };
-    const getDb = (name) => {
-        const entry = entries.get(name);
-        if (!entry || entry.kind !== "db")
-            throw new Error(`DB map '${name}' not found`);
-        return entry.value;
-    };
-    const get = (name) => {
-        const entry = entries.get(name);
-        if (!entry)
-            throw new Error(`Map '${name}' not found`);
-        return entry.value;
-    };
-    const list = () => Array.from(entries.entries()).map(([name, e]) => ({ name, kind: e.kind }));
-    return { api: getApi, db: getDb, get, list };
-}
-/** alias */
-export const loadConfig = createRegistry;

package/db.d.ts

@@ -1,19 +0,0 @@
-export type QueryParams = unknown[] | Record<string, unknown> | undefined;
-export interface DbAdapter {
-    connect(config: Record<string, unknown>): Promise<void>;
-    query<T = unknown>(sql: string, params?: QueryParams): Promise<T[]>;
-    execute?(sql: string, params?: QueryParams): Promise<{
-        affectedRows?: number;
-    }>;
-    close(): Promise<void>;
-}
-export interface Db {
-    connect: (config: Record<string, unknown>) => Promise<void>;
-    query: <T = unknown>(sql: string, params?: QueryParams) => Promise<T[]>;
-    execute: (sql: string, params?: QueryParams) => Promise<{
-        affectedRows?: number;
-    }>;
-    close: () => Promise<void>;
-}
-export declare function createDb(adapter: DbAdapter): Db;
-export type { DbAdapter as IDbAdapter };

package/db.js

@@ -1,15 +0,0 @@
-export function createDb(adapter) {
-    const ensure = (fn) => fn();
-    return {
-        connect: (config) => ensure(() => adapter.connect(config)),
-        query: (sql, params) => ensure(() => adapter.query(sql, params)),
-        execute: (sql, params) => ensure(async () => {
-            if (typeof adapter.execute === "function") {
-                return adapter.execute(sql, params);
-            }
-            await adapter.query(sql, params);
-            return { affectedRows: undefined };
-        }),
-        close: () => ensure(() => adapter.close()),
-    };
-}

package/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./db";
-export * from "./api";
-export * from "./config";
-export * from "./mapper";

package/index.js

@@ -1,4 +0,0 @@
-export * from "./db";
-export * from "./api";
-export * from "./config";
-export * from "./mapper";

package/mapper.d.ts

@@ -1,59 +0,0 @@
-import { type ApiAdapter, type ApiClient } from "./api";
-import { type DbAdapter, type Db, type QueryParams } from "./db";
-import type { MapKind, MapperConfig } from "./config";
-export declare function useConfig(config: MapperConfig): void;
-export declare function list(): {
-    name: string;
-    kind: MapKind;
-}[];
-export interface ApiPath {
-    get<T = unknown>(headers?: Record<string, string>): Promise<{
-        status: number;
-        headers?: Record<string, string>;
-        data?: T;
-    }>;
-    post<T = unknown>(body?: unknown, headers?: Record<string, string>): Promise<{
-        status: number;
-        headers?: Record<string, string>;
-        data?: T;
-    }>;
-    put<T = unknown>(body?: unknown, headers?: Record<string, string>): Promise<{
-        status: number;
-        headers?: Record<string, string>;
-        data?: T;
-    }>;
-    delete<T = unknown>(headers?: Record<string, string>): Promise<{
-        status: number;
-        headers?: Record<string, string>;
-        data?: T;
-    }>;
-}
-export interface DbTable {
-    selectAll<T = unknown>(): Promise<T[]>;
-    query<T = unknown>(sqlSuffix?: string, params?: QueryParams): Promise<T[]>;
-}
-export interface MapperHandle {
-    name(): string;
-    kind(): MapKind;
-    client(): ApiClient | Db;
-    table(name: string): DbTable;
-    path(p: string): ApiPath;
-}
-export interface MapperBuilderStart {
-    create(name: string, kind: MapKind): MapperBuilder;
-}
-export interface MapperBuilder {
-    adapter(adapter: ApiAdapter | DbAdapter): MapperBuilder;
-    save(): MapperHandle;
-    baseUrl(url: string): MapperBuilder;
-    headers(headers: Record<string, string>): MapperBuilder;
-    header(key: string, value: string): MapperBuilder;
-    host(host: string): MapperBuilder;
-    dbname(name: string): MapperBuilder;
-    user(user: string): MapperBuilder;
-    pass(pass: string): MapperBuilder;
-    port(port: number): MapperBuilder;
-    option(key: string, value: unknown): MapperBuilder;
-}
-export declare function mapper(): MapperBuilderStart;
-export declare function mapper(name: string): MapperHandle;

package/mapper.js

@@ -1,117 +0,0 @@
-import { createApiClient } from "./api";
-import { createDb } from "./db";
-const registry = new Map();
-function ensureUnique(name) {
-    if (registry.has(name))
-        throw new Error(`Duplicate map name '${name}'`);
-}
-export function useConfig(config) {
-    for (const m of config.maps) {
-        ensureUnique(m.name);
-        if (m.kind === "api") {
-            const client = createApiClient(m.baseUrl ?? "", m.adapter, m.defaultHeaders);
-            registry.set(m.name, { kind: "api", value: client });
-        }
-        else {
-            const db = createDb(m.adapter);
-            registry.set(m.name, { kind: "db", value: db });
-        }
-    }
-}
-export function list() {
-    return Array.from(registry.entries()).map(([name, e]) => ({ name, kind: e.kind }));
-}
-function asHandle(name, entry) {
-    const base = {
-        name: () => name,
-        kind: () => entry.kind,
-        client: () => entry.value,
-    };
-    const table = (t) => {
-        if (entry.kind !== "db")
-            throw new Error(`Map '${name}' is not a DB. Use path() for API.`);
-        const db = entry.value;
-        return {
-            selectAll: () => db.query(`SELECT * FROM ${t}`),
-            query: (suffix, params) => {
-                const sql = suffix ? `SELECT * FROM ${t} ${suffix}` : `SELECT * FROM ${t}`;
-                return db.query(sql, params);
-            },
-        };
-    };
-    const path = (p) => {
-        if (entry.kind !== "api")
-            throw new Error(`Map '${name}' is not an API. Use table() for DB.`);
-        const api = entry.value;
-        const normalized = p.startsWith("/") ? p : `/${p}`;
-        return {
-            get: (headers) => api.get(normalized, headers),
-            post: (body, headers) => api.post(normalized, body, headers),
-            put: (body, headers) => api.put(normalized, body, headers),
-            delete: (headers) => api.delete(normalized, headers),
-        };
-    };
-    return { ...base, table, path };
-}
-class Builder {
-    constructor() {
-        this.conf = {};
-    }
-    create(name, kind) {
-        this.conf.name = name;
-        this.conf.kind = kind;
-        return this;
-    }
-    adapter(adapter) {
-        this.conf.adapter = adapter;
-        return this;
-    }
-    // API
-    baseUrl(url) { var _a; (_a = this.conf).api ?? (_a.api = {}); this.conf.api.baseUrl = url; return this; }
-    headers(headers) {
-        var _a;
-        (_a = this.conf).api ?? (_a.api = {});
-        const current = this.conf.api.defaultHeaders ?? {};
-        this.conf.api.defaultHeaders = { ...current, ...headers };
-        return this;
-    }
-    header(key, value) { return this.headers({ [key]: value }); }
-    // DB
-    ensureConn() {
-        var _a;
-        (_a = this.conf).db ?? (_a.db = {});
-        if (!this.conf.db.connection)
-            this.conf.db.connection = {};
-    }
-    host(host) { this.ensureConn(); this.conf.db.connection.host = host; return this; }
-    dbname(name) { this.ensureConn(); this.conf.db.connection.dbname = name; return this; }
-    user(user) { this.ensureConn(); this.conf.db.connection.user = user; return this; }
-    pass(pass) { this.ensureConn(); this.conf.db.connection.pass = pass; return this; }
-    port(port) { this.ensureConn(); this.conf.db.connection.port = port; return this; }
-    option(key, value) { this.ensureConn(); this.conf.db.connection[key] = value; return this; }
-    save() {
-        const name = this.conf.name;
-        const kind = this.conf.kind;
-        const adapter = this.conf.adapter;
-        if (!name || !kind || !adapter)
-            throw new Error("Builder requires name, kind, and adapter before save()");
-        ensureUnique(name);
-        if (kind === "api") {
-            const client = createApiClient(this.conf.api?.baseUrl ?? "", adapter, this.conf.api?.defaultHeaders);
-            registry.set(name, { kind: "api", value: client });
-            return asHandle(name, registry.get(name));
-        }
-        const db = createDb(adapter);
-        registry.set(name, { kind: "db", value: db });
-        return asHandle(name, registry.get(name));
-    }
-}
-export function mapper(name) {
-    if (typeof name === "string") {
-        const entry = registry.get(name);
-        if (!entry)
-            throw new Error(`Map '${name}' not found. Register with useConfig() or builder.`);
-        return asHandle(name, entry);
-    }
-    return new Builder();
-}