@neupgroup/mapper 1.6.1 → 1.6.2

package/dist/cli/create-migration.js

@@ -46,34 +46,34 @@ import { Mapper, TableMigrator } from '@neupgroup/mapper';
 export const usesConnection = 'default';
 
 export async function up() {
-    const table = Mapper.schemas().table('${tableName}');
-    table.useConnection(usesConnection);
+    const schema = Mapper.schema().table('${tableName}');
+    schema.useConnection(usesConnection);
 
     /**
-     * CASE 1: CREATE TABLE (Requires .exec())
-     * Use this when defining a new table. addColumn calls are batched.
+     * CASE 1: CREATE SCHEMA (Requires .exec())
+     * Use this when defining a new schema. addColumn calls are batched.
      */
-    // table.addColumn('id').type('int').isPrimary().autoIncrement();
-    // table.addColumn('name').type('string').notNull();
-    // await table.exec(); 
+    // schema.addColumn('id').type('int').isPrimary().autoIncrement();
+    // schema.addColumn('name').type('string').notNull();
+    // await schema.exec(); 
 
     /**
-     * CASE 2: ALTER TABLE (Queued actions)
+     * CASE 2: ALTER SCHEMA (Queued actions)
      * These methods are queued and only execute when you call .exec()
      */
-    // table.dropColumn('old_field');
-    // table.dropUnique('field_name');
-    // await table.exec();
+    // schema.dropColumn('old_field');
+    // schema.dropUnique('field_name');
+    // await schema.exec();
 }
 
 export async function down() {
     /**
-     * DROP TABLE (Immediate action)
-     * This will drop the table from the DB and delete the local schema file.
+     * DROP SCHEMA (Immediate action)
+     * This will drop the schema from the DB and delete the local schema file.
      */
-    const table = Mapper.schemas().table('${tableName}');
-    table.useConnection(usesConnection);
-    await table.dropTable().exec();
+    const schema = Mapper.schema().table('${tableName}');
+    schema.useConnection(usesConnection);
+    await schema.dropTable().exec();
 }
 `;
 fs.writeFileSync(filePath, fileContent.trim());

package/dist/errors.js

@@ -40,7 +40,7 @@ export class SchemaExistingError extends MapperError {
 }
 export class SchemaMissingError extends MapperError {
     constructor(name) {
-        super(`Unknown schema '${name}'.`, 'SCHEMA_UNKNOWN', `Ensure you have defined the schema '${name}' using 'Mapper.schema().create("${name}")...'`);
+        super(`Unknown schema '${name}'.`, 'SCHEMA_UNKNOWN', `The schema '${name}' is not registered. Ensure you have run migrations, called 'Mapper.discover()', or defined it manually using 'Mapper.schema().create("${name}")'.`);
     }
 }
 export class SchemaConfigurationError extends MapperError {

package/dist/fluent-mapper.d.ts

@@ -1,10 +1,28 @@
-import { Connections, SchemaManager, ConnectionType } from './index.js';
+import { Connections, SchemaManager, type SchemaDef, ConnectionType } from './index.js';
 import { TableMigrator } from './migrator.js';
 export declare class FluentQueryBuilder {
     private mapper;
     private schemaName;
     private query;
-    constructor(mapper: any, schemaName: string);
+    private _migrator?;
+    constructor(mapper: any, schemaName: string, connectionName?: string);
+    getDef(): SchemaDef;
+    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);
+    structure(config: any): this;
+    collection(collectionName: string): this;
+    get migrator(): TableMigrator;
+    useConnection(name: string): this;
+    addColumn(name: string): import("./migrator.js").ColumnBuilder;
+    selectColumn(name: string): import("./migrator.js").ColumnBuilder;
+    dropColumn(name: string): this;
+    drop(): this;
+    exec(): Promise<void>;
+    dropTable(): Promise<void>;
     where(field: string, value: any, operator?: string): this;
     whereComplex(raw: string): this;
     limit(n: number): this;
@@ -69,11 +87,11 @@ export declare class FluentConnectionSelector {
     private mapper;
     private connectionName;
     constructor(mapper: any, connectionName: string);
-    schema(schemaName: string): FluentSchemaBuilder;
+    schema(schemaName: string): FluentQueryBuilder;
+    schemas(schemaName: string): FluentQueryBuilder;
     query(schemaName: string): FluentQueryBuilder;
     table(tableName: string): FluentQueryBuilder;
     collection(collectionName: string): FluentQueryBuilder;
-    schemas(schemaName: string): FluentSchemaWrapper;
     path(path: string): FluentApiRequestBuilder;
     header(key: string | Record<string, string | string[]>, value?: string | string[]): FluentApiRequestBuilder;
     headers(headers: Record<string, string> | any[]): FluentApiRequestBuilder;
@@ -87,6 +105,7 @@ export declare class FluentMapper {
     private mapper;
     constructor(mapper: any);
     query(schemaName: string): FluentQueryBuilder;
+    schema(name: string): FluentQueryBuilder;
     table(name: string): FluentQueryBuilder;
     makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
@@ -105,10 +124,12 @@ export declare class StaticMapper {
     static makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     static makeTempConnection(type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     static query(schemaName: string): FluentQueryBuilder;
+    static schema(name: string): FluentQueryBuilder;
+    static schema(): SchemaManagerWrapper;
     static table(name: string): FluentQueryBuilder;
     static connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
     static useConnection(connectionName: string): FluentConnectionSelector;
-    static schemas(name?: string): FluentSchemaWrapper | SchemaManagerWrapper;
+    static schemas(name?: string): any;
     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>;
@@ -120,27 +141,10 @@ 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>;
-    dropTable(): Promise<void>;
-}
 export declare class SchemaManagerWrapper {
     private manager;
     constructor(manager: SchemaManager);
     table(name: string): TableMigrator;
+    schema(name: string): TableMigrator;
     dropTable(name: string): Promise<void>;
 }

package/dist/fluent-mapper.js

@@ -1,10 +1,99 @@
 import { createMapper } from './mapper.js';
 import { TableMigrator } from './migrator.js';
 export class FluentQueryBuilder {
-    constructor(mapper, schemaName) {
+    constructor(mapper, schemaName, connectionName) {
         this.mapper = mapper;
         this.schemaName = schemaName;
-        this.query = mapper.use(schemaName);
+        try {
+            this.query = mapper.use(schemaName);
+            if (connectionName) {
+                const def = this.getDef();
+                if (def)
+                    def.connectionName = connectionName;
+            }
+        }
+        catch (e) {
+            // Auto-register schema if missing (Automatically schemas!)
+            mapper.getSchemaManager().create(schemaName).use({ connection: connectionName || 'default', collection: schemaName }).setStructure({});
+            this.query = mapper.use(schemaName);
+        }
+    }
+    getDef() {
+        return this.mapper.getSchemaManager().schemas.get(this.schemaName);
+    }
+    set fields(config) {
+        const def = this.getDef();
+        if (def) {
+            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;
+    }
+    structure(config) {
+        this.fields = config;
+        return this;
+    }
+    collection(collectionName) {
+        const def = this.getDef();
+        if (def)
+            def.collectionName = collectionName;
+        return this;
+    }
+    get migrator() {
+        if (!this._migrator) {
+            this._migrator = new TableMigrator(this.schemaName);
+            // Sync connection if already set on query
+            const def = this.getDef();
+            if (def === null || def === void 0 ? void 0 : def.connectionName) {
+                this._migrator.useConnection(def.connectionName);
+            }
+        }
+        return this._migrator;
+    }
+    // Migration/DDL Methods (Proxied to internal migrator)
+    useConnection(name) {
+        this.migrator.useConnection(name);
+        const def = this.getDef();
+        if (def)
+            def.connectionName = name;
+        return this;
+    }
+    addColumn(name) { return this.migrator.addColumn(name); }
+    selectColumn(name) { return this.migrator.selectColumn(name); }
+    dropColumn(name) { this.migrator.dropColumn(name); return this; }
+    drop() { this.migrator.drop(); return this; }
+    async exec() {
+        return this.migrator.exec();
+    }
+    async dropTable() {
+        return this.migrator.drop().exec();
     }
     where(field, value, operator) {
         this.query.where(field, value, operator);
@@ -190,19 +279,19 @@ export class FluentConnectionSelector {
         this.connectionName = connectionName;
     }
     schema(schemaName) {
-        return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
+        return new FluentQueryBuilder(this.mapper, schemaName, this.connectionName);
+    }
+    schemas(schemaName) {
+        return this.schema(schemaName);
     }
     query(schemaName) {
-        return new FluentQueryBuilder(this.mapper, schemaName);
+        return this.schema(schemaName);
     }
     table(tableName) {
-        return this.query(tableName);
+        return this.schema(tableName);
     }
     collection(collectionName) {
-        return this.query(collectionName);
-    }
-    schemas(schemaName) {
-        return new FluentSchemaWrapper(this.mapper.getSchemaManager(), schemaName, this.connectionName);
+        return this.schema(collectionName);
     }
     // API Request methods
     path(path) {
@@ -237,6 +326,9 @@ export class FluentMapper {
     query(schemaName) {
         return new FluentQueryBuilder(this.mapper, schemaName);
     }
+    schema(name) {
+        return this.query(name);
+    }
     table(name) {
         return this.query(name);
     }
@@ -306,8 +398,13 @@ export class StaticMapper {
     static query(schemaName) {
         return StaticMapper.getFluentMapper().query(schemaName);
     }
+    static schema(name) {
+        if (name)
+            return StaticMapper.getFluentMapper().schema(name);
+        return StaticMapper.schemas();
+    }
     static table(name) {
-        return StaticMapper.query(name);
+        return StaticMapper.schema(name);
     }
     // New API
     static connection(connectionOrConfig) {
@@ -318,9 +415,8 @@ export class StaticMapper {
         return StaticMapper.connection(connectionName);
     }
     static schemas(name) {
-        if (name) {
-            return new FluentSchemaWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager(), name);
-        }
+        if (name)
+            return StaticMapper.schema(name);
         return new SchemaManagerWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager());
     }
     // Direct static methods
@@ -353,98 +449,6 @@ 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);
-    }
-    async dropTable() {
-        const migrator = new TableMigrator(this.name);
-        if (this.connectionName) {
-            migrator.useConnection(this.connectionName);
-        }
-        return migrator.drop().exec();
-    }
-}
 // 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.
@@ -457,6 +461,9 @@ export class SchemaManagerWrapper {
         // This allows Mapper.schemas().table('name') to return a migrator
         return new TableMigrator(name);
     }
+    schema(name) {
+        return this.table(name);
+    }
     async dropTable(name) {
         return new TableMigrator(name).drop().exec();
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@neupgroup/mapper",
   "description": "Neup.Mapper core library for schema and mapping utilities",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",