@neupgroup/mapper 1.1.0 → 1.2.1

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