@neupgroup/mapper 1.2.3 → 1.2.4

package/dist/fluent-mapper.d.ts

@@ -1,3 +1,4 @@
+import { SchemaManager } from './index.js';
 export declare class FluentQueryBuilder {
     private mapper;
     private schemaName;
@@ -5,10 +6,14 @@ export declare class FluentQueryBuilder {
     constructor(mapper: any, schemaName: string);
     where(field: string, value: any, operator?: string): this;
     whereComplex(raw: string): this;
+    limit(n: number): this;
+    offset(n: number): this;
     to(update: Record<string, any>): this;
-    get(): Promise<Record<string, any>[]>;
+    get(...fields: string[]): any;
+    then(onfulfilled?: ((value: any) => any) | null, onrejected?: ((reason: any) => any) | null): Promise<any>;
     getOne(): Promise<Record<string, any> | null>;
     add(data: Record<string, any>): Promise<any>;
+    insert(data: Record<string, any>): Promise<any>;
     update(): Promise<void>;
     delete(): Promise<void>;
     deleteOne(): Promise<void>;
@@ -49,6 +54,9 @@ export declare class FluentConnectionSelector {
     constructor(mapper: any, connectionName: string);
     schema(schemaName: string): FluentSchemaBuilder;
     query(schemaName: string): FluentQueryBuilder;
+    table(tableName: string): FluentQueryBuilder;
+    collection(collectionName: string): FluentQueryBuilder;
+    schemas(schemaName: string): FluentSchemaWrapper;
 }
 export declare class FluentMapper {
     private mapper;
@@ -56,6 +64,7 @@ export declare class FluentMapper {
     query(schemaName: string): FluentQueryBuilder;
     makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
+    connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
     makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
     get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
     getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
@@ -67,9 +76,11 @@ export declare class StaticMapper {
     private static instance;
     private static getFluentMapper;
     static makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
-    static useConnection(connectionName: string): FluentConnectionSelector;
     static makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
     static query(schemaName: string): FluentQueryBuilder;
+    static connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
+    static useConnection(connectionName: string): FluentConnectionSelector;
+    static schemas(name: string): FluentSchemaWrapper;
     static get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
     static getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
     static add(schemaName: string, data: Record<string, any>): Promise<any>;
@@ -78,3 +89,20 @@ export declare class StaticMapper {
 }
 export declare const Mapper: typeof StaticMapper;
 export default Mapper;
+export declare class FluentSchemaWrapper {
+    private manager;
+    private name;
+    private connectionName?;
+    constructor(manager: SchemaManager, name: string, connectionName?: string | undefined);
+    private getDef;
+    set fields(config: any);
+    set insertableFields(val: string[]);
+    set updatableFields(val: string[]);
+    set deleteType(val: 'softDelete' | 'hardDelete');
+    set massDeleteAllowed(val: boolean);
+    set massEditAllowed(val: boolean);
+    get(...fields: string[]): any;
+    limit(n: number): FluentQueryBuilder;
+    offset(n: number): FluentQueryBuilder;
+    insert(data: Record<string, any>): Promise<any>;
+}

package/dist/fluent-mapper.js

@@ -13,12 +13,36 @@ export class FluentQueryBuilder {
         this.query.whereComplex(raw);
         return this;
     }
+    limit(n) {
+        this.query.limit(n);
+        return this;
+    }
+    offset(n) {
+        this.query.offset(n);
+        return this;
+    }
     to(update) {
         this.query.to(update);
         return this;
     }
-    async get() {
-        return this.query.get();
+    // If args provided, act as SELECT (projection) and return this.
+    // If no args, act as execute() (but this class is thenable so we can just return this if we want consistency, 
+    // but existing API returns Promise directly. To check user intent:
+    // User: get('f1').limit(1).
+    // So get('f1') must return this.
+    get(...fields) {
+        if (fields.length > 0) {
+            // Apply field selection? SchemaQuery needs a way to filter fields.
+            // We'll add this capability to Field filtering in SchemaQuery or just use 'fields' option in buildOptions.
+            // For now, let's assume we can modify the query's field list.
+            this.query.selectFields(fields);
+            return this;
+        }
+        return this.query.get(); // Promise
+    }
+    // Make the builder thenable
+    then(onfulfilled, onrejected) {
+        return this.query.get().then(onfulfilled, onrejected);
     }
     async getOne() {
         return this.query.getOne();
@@ -26,6 +50,9 @@ export class FluentQueryBuilder {
     async add(data) {
         return this.mapper.add(this.schemaName, data);
     }
+    async insert(data) {
+        return this.add(data);
+    }
     async update() {
         return this.query.update();
     }
@@ -93,6 +120,15 @@ export class FluentConnectionSelector {
     query(schemaName) {
         return new FluentQueryBuilder(this.mapper, schemaName);
     }
+    table(tableName) {
+        return this.query(tableName);
+    }
+    collection(collectionName) {
+        return this.query(collectionName);
+    }
+    schemas(schemaName) {
+        return new FluentSchemaWrapper(this.mapper.getSchemaManager(), schemaName, this.connectionName);
+    }
 }
 export class FluentMapper {
     constructor(mapper) {
@@ -104,9 +140,27 @@ export class FluentMapper {
     makeConnection(name, type, config) {
         return new FluentConnectionBuilder(this.mapper, name, type, config);
     }
+    // Deprecated: use connection() instead
     useConnection(connectionName) {
         return new FluentConnectionSelector(this.mapper, connectionName);
     }
+    connection(connectionOrConfig) {
+        if (typeof connectionOrConfig === 'string') {
+            return new FluentConnectionSelector(this.mapper, connectionOrConfig);
+        }
+        // Handle object config: create temp connection
+        // Expected format: { type: '...', ...others }
+        const type = connectionOrConfig.type;
+        if (!type) {
+            throw new Error("Connection configuration must specify 'type'");
+        }
+        const config = { ...connectionOrConfig };
+        delete config.type;
+        // Create temp connection
+        const tempName = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        new FluentConnectionBuilder(this.mapper, tempName, type, config); // Registers it
+        return new FluentConnectionSelector(this.mapper, tempName);
+    }
     makeTempConnection(type, config) {
         const tempName = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         return new FluentConnectionBuilder(this.mapper, tempName, type, config);
@@ -140,15 +194,24 @@ export class StaticMapper {
     static makeConnection(name, type, config) {
         return StaticMapper.getFluentMapper().makeConnection(name, type, config);
     }
-    static useConnection(connectionName) {
-        return StaticMapper.getFluentMapper().useConnection(connectionName);
-    }
     static makeTempConnection(type, config) {
         return StaticMapper.getFluentMapper().makeTempConnection(type, config);
     }
     static query(schemaName) {
         return StaticMapper.getFluentMapper().query(schemaName);
     }
+    // New API
+    static connection(connectionOrConfig) {
+        return StaticMapper.getFluentMapper().connection(connectionOrConfig);
+    }
+    // Deprecated alias
+    static useConnection(connectionName) {
+        return StaticMapper.connection(connectionName);
+    }
+    static schemas(name) {
+        return new FluentSchemaWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager(), // Access underlying manager
+        name);
+    }
     // Direct static methods
     static async get(schemaName, filters) {
         return StaticMapper.getFluentMapper().get(schemaName, filters);
@@ -169,3 +232,92 @@ export class StaticMapper {
 // Export a default instance for convenience
 export const Mapper = StaticMapper;
 export default Mapper;
+export class FluentSchemaWrapper {
+    // builder unused
+    constructor(manager, name, connectionName) {
+        this.manager = manager;
+        this.name = name;
+        this.connectionName = connectionName;
+        // Ensure schema exists or create it?
+        // User pattern: Mapper.schemas('name').fields = ...
+        // So we likely need to create it if missing, or update it.
+        try {
+            this.manager.create(name).use({ connection: connectionName || 'default', collection: name }).setStructure({});
+        }
+        catch (e) {
+            // Ignore if exists, but maybe update connection if strictly provided?
+            // Use existing definition if available.
+        }
+    }
+    getDef() {
+        // Access private map from manager? Or expose a get method.
+        // Manager has .schemas map.
+        return this.manager.schemas.get(this.name);
+    }
+    set fields(config) {
+        // Update schema structure
+        const builder = new FluentSchemaBuilder(null, this.name, ''); // Dummy wrapper or use internal
+        // Easier: use Manager.create(name) returns SchemaBuilder which has setStructure.
+        // But if it exists, create() throws.
+        // We need 'update' or direct access.
+        // Let's hack: re-register or update def.
+        const def = this.getDef();
+        if (def) {
+            // Re-parse
+            const parsed = parseDescriptorStructure(config);
+            def.fields = parsed.fields;
+            def.fieldsMap = new Map();
+            def.fields.forEach((f) => def.fieldsMap.set(f.name, f));
+            def.allowUndefinedFields = parsed.allowUndefinedFields;
+        }
+    }
+    set insertableFields(val) {
+        const def = this.getDef();
+        if (def)
+            def.insertableFields = val;
+    }
+    set updatableFields(val) {
+        const def = this.getDef();
+        if (def)
+            def.updatableFields = val;
+    }
+    set deleteType(val) {
+        const def = this.getDef();
+        if (def)
+            def.deleteType = val;
+    }
+    set massDeleteAllowed(val) {
+        const def = this.getDef();
+        if (def)
+            def.massDeleteAllowed = val;
+    }
+    set massEditAllowed(val) {
+        const def = this.getDef();
+        if (def)
+            def.massEditAllowed = val;
+    }
+    // Delegation to QueryBuilder
+    get(...fields) {
+        const q = new FluentQueryBuilder({ use: (n) => this.manager.use(n) }, this.name);
+        return q.get(...fields);
+    }
+    limit(n) {
+        const q = new FluentQueryBuilder({ use: (n) => this.manager.use(n) }, this.name);
+        return q.limit(n);
+    }
+    offset(n) {
+        const q = new FluentQueryBuilder({ use: (n) => this.manager.use(n) }, this.name);
+        return q.offset(n);
+    }
+    async insert(data) {
+        const q = new FluentQueryBuilder({
+            use: (n) => this.manager.use(n),
+            add: (n, d) => this.manager.use(n).add(d)
+        }, this.name);
+        return q.insert(data);
+    }
+}
+// Helper to access parseDescriptorStructure from index.ts if not exported?
+// It is NOT exported. I need to export it or duplicate logic.
+// I'll export it from index.ts.
+import { parseDescriptorStructure } from './index.js'; // fixed import at bottom

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import type { DbAdapter, QueryOptions } from './orm';
-import Mapper from './mapper';
+import type { DbAdapter, QueryOptions } from './orm/index.js';
 export type ColumnType = 'string' | 'number' | 'boolean' | 'date' | 'int';
 export type ConnectionType = 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api';
 export interface Field {
@@ -8,14 +7,25 @@ export interface Field {
     editable?: boolean;
     autoIncrement?: boolean;
     nullable?: boolean;
-    defaultValue?: unknown;
+    defaultValue?: any;
+    isUnique?: boolean;
+    isForeignKey?: boolean;
+    foreignRef?: string;
+    enumValues?: any[];
+    config?: any[];
 }
 export interface SchemaDef {
     name: string;
     connectionName: string;
     collectionName: string;
     fields: Field[];
+    fieldsMap: Map<string, Field>;
     allowUndefinedFields?: boolean;
+    insertableFields?: string[];
+    updatableFields?: string[];
+    deleteType: 'softDelete' | 'hardDelete';
+    massDeleteAllowed: boolean;
+    massEditAllowed: boolean;
 }
 interface ConnectionConfig {
     name: string;
@@ -39,6 +49,10 @@ export declare class Connections {
     getAdapter(name: string): DbAdapter | undefined;
     list(): ConnectionConfig[];
 }
+export declare function parseDescriptorStructure(struct: Record<string, string | any[]>): {
+    fields: Field[];
+    allowUndefinedFields: boolean;
+};
 declare class SchemaBuilder {
     private manager;
     private name;
@@ -46,12 +60,24 @@ declare class SchemaBuilder {
     private collectionName?;
     private fields;
     private allowUndefinedFields;
+    private insertableFields?;
+    private updatableFields?;
+    private deleteType;
+    private massDeleteAllowed;
+    private massEditAllowed;
     constructor(manager: SchemaManager, name: string);
     use(options: {
         connection: string;
         collection: string;
     }): this;
-    setStructure(structure: Record<string, string> | Field[]): SchemaManager;
+    setOptions(options: {
+        insertableFields?: string[];
+        updatableFields?: string[];
+        deleteType?: 'softDelete' | 'hardDelete';
+        massDeleteAllowed?: boolean;
+        massEditAllowed?: boolean;
+    }): this;
+    setStructure(structure: Record<string, any> | Field[]): SchemaManager;
 }
 declare class SchemaQuery {
     private manager;
@@ -59,10 +85,19 @@ declare class SchemaQuery {
     private filters;
     private rawWhere;
     private pendingUpdate;
+    private cachedAdapter;
+    private cachedFieldNames;
+    private allowedFields;
+    private _limit;
+    private _offset;
     constructor(manager: SchemaManager, def: SchemaDef);
+    limit(n: number): this;
+    offset(n: number): this;
+    selectFields(fields: string[]): this;
     where(fieldOrPair: string | [string, any], value?: any, operator?: string): this;
     whereComplex(raw: string): this;
     private buildOptions;
+    private getAdapter;
     to(update: Record<string, any>): this;
     get(): Promise<Record<string, any>[]>;
     getOne(): Promise<Record<string, any> | null>;
@@ -85,14 +120,18 @@ export declare class SchemaManager {
 export declare function connection(): Connections;
 export declare function schema(conns?: Connections): SchemaManager;
 export declare const schemas: SchemaManager;
-export { createOrm } from './orm';
+export { createOrm } from './orm/index.js';
 export type { DbAdapter, QueryOptions };
-export { parseConnectionsDsl, toNormalizedConnections } from './env';
-export type { EnvDslConnections, NormalizedConnection } from './env';
-export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';
-export { Mapper, createMapper } from './mapper';
-export default Mapper;
-export { StaticMapper } from './fluent-mapper';
-export type { FluentQueryBuilder, FluentConnectionBuilder, FluentSchemaBuilder, FluentSchemaCollectionBuilder, FluentConnectionSelector, FluentMapper } from './fluent-mapper';
-export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config';
-export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig, ConfigSchema } from './config';
+export { parseConnectionsDsl, toNormalizedConnections } from './env.js';
+export type { EnvDslConnections, NormalizedConnection } from './env.js';
+export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs.js';
+export { Mapper, createMapper } from './mapper.js';
+export { default } from './mapper.js';
+export { StaticMapper } from './fluent-mapper.js';
+export type { FluentQueryBuilder, FluentConnectionBuilder, FluentSchemaBuilder, FluentSchemaCollectionBuilder, FluentConnectionSelector, FluentMapper } from './fluent-mapper.js';
+export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config.js';
+export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig, ConfigSchema } from './config.js';
+export { MySQLAdapter, createMySQLAdapter, PostgreSQLAdapter, createPostgreSQLAdapter, MongoDBAdapter, createMongoDBAdapter, APIAdapter, createAPIAdapter, createAdapter, createAdapterFromUrl, autoAttachAdapter } from './adapters/index.js';
+export type { MySQLConfig, PostgreSQLConfig, MongoDBConfig, APIAdapterConfig, AdapterConfig } from './adapters/index.js';
+export { MapperError, AdapterMissingError, UpdatePayloadMissingError, DocumentMissingIdError, ConnectionExistingError, ConnectionUnknownError, SchemaExistingError, SchemaMissingError, SchemaConfigurationError, } from './errors.js';
+export { Connector, mapper } from './connector.js';