@neupgroup/mapper 1.0.0 → 1.2.0

package/README.md

@@ -1,66 +1,37 @@
-# Neup.Mapper (Library)
-
-Neup.Mapper is now a small, framework-agnostic TypeScript library focused on two things:
-
-- Database connectivity via adapter pattern (bring your own driver)
-- HTTP API access via adapter pattern (bring your own client)
-
-## Install
-
-This project is currently private. Build locally:
-
-```
-npm install
-npm run build
-```
-
-Artifacts are emitted to `dist/`.
-
-## Usage
-
-### Database
-
-```
-import { createDb, IDbAdapter } from "neup-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 "neup-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");
-```
-
-## Layout
-
-- Source files live at the project root: `index.ts`, `db.ts`, `api.ts`.
-- Build emits to `dist/` with `index.js` and `index.d.ts` for consumers.
-- No React/Next.js UI is included; the project is library-only.
-- Add any DB driver or HTTP client as dependencies in your own app.
+# @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.0.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/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,2 +0,0 @@
-export * from "./db";
-export * from "./api";

package/index.js

@@ -1,2 +0,0 @@
-export * from "./db";
-export * from "./api";