@neupgroup/mapper 1.5.3 → 1.5.4

package/dist/config.d.ts

@@ -1,13 +1,22 @@
-import { Connections, SchemaManager } from './index.js';
+import { Connections, SchemaManager, ConnectionType } from './index.js';
 export interface DatabaseConnectionConfig {
     name: string;
-    type: 'mysql' | 'sql' | 'firestore' | 'mongodb';
-    host: string;
-    port: number;
-    database: string;
-    user: string;
+    type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'postgres' | 'sqlite';
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
     password?: string;
     ssl?: boolean;
+    filename?: string;
+    mode?: number;
+    [key: string]: any;
+}
+export interface SqliteConnectionConfig {
+    name: string;
+    type: 'sqlite';
+    filename: string;
+    mode?: number;
     [key: string]: any;
 }
 export interface ApiConnectionConfig {
@@ -18,7 +27,7 @@ export interface ApiConnectionConfig {
     timeout?: number;
     [key: string]: any;
 }
-export type ConnectionConfig = DatabaseConnectionConfig | ApiConnectionConfig;
+export type ConnectionConfig = DatabaseConnectionConfig | ApiConnectionConfig | SqliteConnectionConfig;
 export interface ConfigSchema {
     name: string;
     connection: string;
@@ -55,7 +64,7 @@ export declare class ConfigBasedMapper {
     getSchemaManager(): SchemaManager;
     use(schemaName: string): any;
     schema(name: string): any;
-    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): import("./mapper.js").Mapper;
+    connect(name: string, type: ConnectionType, config: Record<string, any>): import("./mapper.js").Mapper;
     get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
     getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
     add(schemaName: string, data: Record<string, any>): Promise<any>;

package/dist/config.js

@@ -224,11 +224,13 @@ function inferConnectionType(url) {
     if (url.includes('mysql'))
         return 'mysql';
     if (url.includes('postgres') || url.includes('postgresql'))
-        return 'sql';
+        return 'postgres';
     if (url.includes('mongodb'))
         return 'mongodb';
     if (url.includes('firestore'))
         return 'firestore';
+    if (url.includes('sqlite') || url.endsWith('.db') || url.endsWith('.sqlite'))
+        return 'sqlite';
     return 'sql'; // default to sql
 }
 export default ConfigBasedMapper;

package/dist/env.d.ts

@@ -1,3 +1,4 @@
+import { ConnectionType } from './index.js';
 export type EnvDslConnections = Record<string, Record<string, string>>;
 /**
  * Parse a simple DSL of the form:
@@ -15,7 +16,7 @@ export type EnvDslConnections = Record<string, Record<string, string>>;
 export declare function parseConnectionsDsl(text: string): EnvDslConnections;
 export type NormalizedConnection = {
     name: string;
-    type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api';
+    type: ConnectionType;
     key: Record<string, any>;
 };
 /**

package/dist/env.js

@@ -80,7 +80,7 @@ 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 = ['mysql', 'sql', 'firestore', 'mongodb', 'postgres', 'api', 'sqlite'].includes(rawType) ? rawType : 'api';
         const { type: _omitType, dbType: _omitDbType, ...rest } = kv;
         conns.push({ name, type, key: rest });
     }

package/dist/fluent-mapper.d.ts

@@ -1,4 +1,4 @@
-import { SchemaManager } from './index.js';
+import { SchemaManager, ConnectionType } from './index.js';
 import { TableMigrator } from './migrator.js';
 export declare class FluentQueryBuilder {
     private mapper;
@@ -87,10 +87,10 @@ export declare class FluentMapper {
     private mapper;
     constructor(mapper: any);
     query(schemaName: string): FluentQueryBuilder;
-    makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
+    makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
     connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
-    makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
+    makeTempConnection(type: ConnectionType, 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>;
     add(schemaName: string, data: Record<string, any>): Promise<any>;
@@ -100,8 +100,8 @@ export declare class FluentMapper {
 export declare class StaticMapper {
     private static instance;
     private static getFluentMapper;
-    static makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
-    static makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): FluentConnectionBuilder;
+    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 connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
     static useConnection(connectionName: string): FluentConnectionSelector;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { DbAdapter, QueryOptions } from './orm/index.js';
 export type ColumnType = 'string' | 'number' | 'boolean' | 'date' | 'int';
-export type ConnectionType = 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite';
+export type ConnectionType = 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'postgres' | 'api' | 'sqlite';
 export interface Field {
     name: string;
     type: ColumnType;
@@ -130,7 +130,7 @@ 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 type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig, SqliteConnectionConfig, 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';

package/dist/mapper.d.ts

@@ -1,4 +1,4 @@
-import { Connections, SchemaManager } from './index.js';
+import { Connections, SchemaManager, ConnectionType } from './index.js';
 export declare class Mapper {
     private connections;
     private schemaManager;
@@ -12,7 +12,7 @@ export declare class Mapper {
     private applyConfig;
     private applyDefaultConfig;
     private createSchema;
-    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api' | 'sqlite', config: Record<string, any>): this;
+    connect(name: string, type: ConnectionType, config: Record<string, any>): this;
     schema(name: string): ReturnType<SchemaManager['create']>;
     use(schemaName: string): ReturnType<SchemaManager['use']>;
     get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;

package/dist/mapper.js

@@ -53,7 +53,7 @@ export class Mapper {
         if (url.includes('mysql'))
             return 'mysql';
         if (url.includes('postgres') || url.includes('postgresql'))
-            return 'sql';
+            return 'postgres';
         if (url.includes('mongodb'))
             return 'mongodb';
         if (url.includes('firestore'))

package/package.json

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

package/dist/usage_example.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/usage_example.js

@@ -1,37 +0,0 @@
-import { Mapper } from './fluent-mapper.js';
-async function main() {
-    // 1. Connection setup (mock)
-    Mapper.makeConnection('custom', 'api', { url: 'http://localhost' });
-    // 2. Schema Definition using the new API
-    const userSchema = Mapper.schemas('users');
-    userSchema.fields = {
-        'id': ['integer', 'auto-increment'],
-        'name': ['string', 'max.20', 'unique'],
-        'gender': ['string', 'enum', ['male', 'female', 'other']],
-        'createdOn': ['datetime', 'default_current_datetime'],
-        'role': ['string', 'default.value', 'user']
-    };
-    userSchema.insertableFields = ['name', 'gender', 'role']; // exclude id, createdOn
-    userSchema.updatableFields = ['name', 'gender'];
-    userSchema.deleteType = 'softDelete';
-    userSchema.massDeleteAllowed = false;
-    console.log("Schema defined.");
-    // 3. User Query Scenarios
-    // Scenario A: Mapper.connection('name').table('name')
-    // We don't have a real DB so this will fail at execution but we check the builder construction.
-    const query1 = Mapper.connection('default').table('users');
-    console.log("Query 1 built:", query1);
-    // Scenario B: Mapper.connection('name').schemas('name').get('users').limit(1)
-    // 'users' in get() might be field selection if schema is 'name'. 
-    // Let's assume 'users' is the schema name.
-    // Code: Mapper.connection('default').schemas('users').get('id', 'name').limit(1)
-    const query2 = Mapper.connection('default').schemas('users').get('id', 'name').limit(1);
-    console.log("Query 2 built (select fields):", query2);
-    // Scenario C: Mapper.schemas('name').get('field1','field2').limit(2).offset(20)
-    const query3 = Mapper.schemas('users').get('name', 'gender').limit(2).offset(20);
-    console.log("Query 3 built:", query3);
-    // 4. Test logic (mock execution would happen here)
-    // Since we don't have a real adapter that works without network/db, we just stop here.
-    // If we had an in-memory adapter we could test output.
-}
-main().catch(console.error);

package/dist/usage_example_v2.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/usage_example_v2.js

@@ -1,19 +0,0 @@
-import { Mapper } from './fluent-mapper.js';
-async function main() {
-    // 1. Connection setup (mock) with new API
-    // Using configuration object directly
-    // Mapper.connection(['type': 'type', 'username':'username' ]) -> { type: 'api', ... }
-    const conn = Mapper.connection({ type: 'api', url: 'http://example.com' });
-    console.log("Connection created:", conn);
-    // 2. Insert with new API
-    // Mapper.connection('connectionName').collection('name').insert({...})
-    // Let's use the temp connection we just made (it is anonymous/temp in our implementation if using config object, 
-    // but wait, `connection({ type: ... })` returns a selector bound to a temp name.
-    // We need to access a collection/table from the connection selector.
-    // The user requirement: Mapper.connection(...).collection('name').insert(...)
-    // Check references: FluentConnectionSelector has `schema` and `query` and `table`.
-    // Does it have `collection`? No, let's check FluentConnectionSelector.
-    // It has `schema(name)` and `query(name)` and `table(name)`.
-    // We should add `collection(name)` alias.
-}
-main().catch(console.error);