@neupgroup/mapper 1.1.0 → 1.2.1

package/dist/env.js

@@ -0,0 +1,88 @@
+function stripComments(input) {
+    return input
+        .split(/\r?\n/)
+        .map(line => line.replace(/#.*$/, ''))
+        .join('\n');
+}
+function unquote(val) {
+    const trimmed = val.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+/**
+ * Parse a simple DSL of the form:
+ * connections = [
+ *   connectionName = [
+ *     key: value,
+ *     key2: "value2",
+ *   ],
+ *   other = [
+ *     type: SQL,
+ *     host: localhost,
+ *   ]
+ * ]
+ */
+export function parseConnectionsDsl(text) {
+    const cleaned = stripComments(text);
+    const result = {};
+    // Find the connections block
+    const match = cleaned.match(/connections\s*=\s*\[/i);
+    if (!match)
+        return result;
+    // Extract everything after 'connections = [' and before the final ']'
+    const start = match.index + match[0].length;
+    const after = cleaned.slice(start);
+    // naive bracket balance to find end of top-level list
+    let depth = 1;
+    let endIndex = -1;
+    for (let i = 0; i < after.length; i++) {
+        const ch = after[i];
+        if (ch === '[')
+            depth++;
+        else if (ch === ']') {
+            depth--;
+            if (depth === 0) {
+                endIndex = i;
+                break;
+            }
+        }
+    }
+    const inner = endIndex >= 0 ? after.slice(0, endIndex) : after;
+    // Split by connection assignments at top level: name = [ ... ]
+    const connBlocks = inner.split(/\],?/).map(s => s.trim()).filter(Boolean);
+    for (const block of connBlocks) {
+        const assign = block.match(/^(\w[\w-]*)\s*=\s*\[/);
+        if (!assign)
+            continue;
+        const name = assign[1];
+        const content = block.slice(assign[0].length); // inside the [ ...
+        const lines = content.split(/\r?\n|,/).map(l => l.trim()).filter(l => l.length);
+        const map = {};
+        for (const line of lines) {
+            const kv = line.match(/^(\w[\w-]*)\s*:\s*(.+)$/);
+            if (!kv)
+                continue;
+            const key = kv[1];
+            const value = unquote(kv[2].replace(/,\s*$/, ''));
+            map[key] = value;
+        }
+        result[name] = map;
+    }
+    return result;
+}
+/**
+ * Convert DSL map to normalized connections compatible with library Connections.
+ * If no explicit type is provided, defaults to 'api'.
+ */
+export function toNormalizedConnections(map) {
+    const conns = [];
+    for (const [name, kv] of Object.entries(map)) {
+        const rawType = (kv['type'] || kv['dbType'] || '').toLowerCase();
+        const type = ['mysql', 'sql', 'firestore', 'mongodb', 'api'].includes(rawType) ? rawType : 'api';
+        const { type: _omitType, dbType: _omitDbType, ...rest } = kv;
+        conns.push({ name, type, key: rest });
+    }
+    return conns;
+}

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+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 };
+export { parseConnectionsDsl, toNormalizedConnections } from './env';
+export type { EnvDslConnections, NormalizedConnection } from './env';
+export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';

package/dist/index.js

@@ -0,0 +1,280 @@
+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';
+export { parseConnectionsDsl, toNormalizedConnections } from './env';
+export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';

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.1",
+  "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;