Class Prorm

Main Prorm class with error handling and logging

Hierarchy

EventEmitter
- Prorm

Index

Constructors

constructor

new Prorm(options: PrormOptions): Prorm

Create a new Prorm instance

Parameters

options: PrormOptions
Configuration options

Returns Prorm

Example

// Basic usage with console logging
const prorm = new Prorm({
  dialect: 'sqlite',
  storage: ':memory:',
  logging: console.log
});

Example

// Custom logging function that receives SQL and timing
const prorm = new Prorm({
  dialect: 'sqlite',
  storage: ':memory:',
  logging: (sql, timing) => {
    console.log(`Query took ${timing}ms: ${sql}`);
  }
});

Example

// Enable benchmark mode for query timing
const prorm = new Prorm({
  dialect: 'sqlite',
  storage: ':memory:',
  logging: console.log
});

// Now all queries will log execution time
await User.findAll({ benchmark: true });

Example

// Listen to query events
prorm.on('query', (event) => {
  console.log('Query executed:', event.sql, 'Duration:', event.duration, 'ms');
});

// Listen to slow query events
prorm.on('slowQuery', (event) => {
  console.warn('Slow query detected:', event.sql, 'Duration:', event.duration, 'ms', 'Threshold:', event.threshold);
});

Properties

connectionManager

connectionManager: ConnectionRegistry | null = null

The registry this instance was created by, if any.

ConnectionManager.addConnection() sets this on the instance it builds, which is what makes FindOptions.using work: a query can name a sibling connection and be routed to that connection's copy of the model. Nothing else assigned it before, so using threw "Available: none" on every call. Typed structurally (rather than as ConnectionManager) to keep prorm.ts free of an import cycle with connection-manager.ts.

associations

associations: Map<string, any> = ...

`Readonly`externalStores

externalStores: ExternalStoreRegistry = ...

Object/key-value stores backing

External Field

properties. Public so the instance accessors built in _wrapInstance can resolve them.

pool

pool: DatabaseConnectionPool | null = null

The connection pool instance

Example

// Get pool statistics
console.log('Pool size:', prorm.pool.size);
console.log('Available:', prorm.pool.available);
console.log('Used:', prorm.pool.used);
console.log('Pending:', prorm.pool.pending);

// Listen to pool events
prorm.pool.on('acquire', (connection) => {
  console.log('Connection acquired:', connection?.id);
});
prorm.pool.on('release', (connection) => {
  console.log('Connection released:', connection?.id);
});
prorm.pool.on('error', (err) => {
  console.error('Pool error:', err);
});

// Manually acquire a connection
const conn = await prorm.pool.acquire();

// Release a connection
prorm.pool.release(conn);

// Destroy a connection
await prorm.pool.destroy(conn);

Accessors

models

get models(): Record<string, ModelStatic<AnyModel>>
Get all models as an object for backward compatibility Allows accessing models via prorm.models.ModelName

Returns Record<string, ModelStatic<AnyModel>>
- Defined in prorm.ts:549

modelManager

get modelManager(): {
    models: Record<string, ModelStatic<AnyModel>>;
    all: ModelStatic<any>[];
    getModel(name: string): ModelStatic<any> | undefined;
    addModel(name: string, model: ModelStatic<any>): void;
    removeModel(name: string): boolean;
}
Sequelize-style model manager, exposing the registered models along with a few convenience accessors on top of the internal model map.

Returns {
    models: Record<string, ModelStatic<AnyModel>>;
    all: ModelStatic<any>[];
    getModel(name: string): ModelStatic<any> | undefined;
    addModel(name: string, model: ModelStatic<any>): void;
    removeModel(name: string): boolean;
}
- Defined in prorm.ts:557

isConnected

get isConnected(): boolean
Check if connected

Returns boolean
- Defined in prorm.ts:1233

allModels

get allModels(): Record<string, ModelStatic<AnyModel>>
Get all models as an object (for backward compatibility)

Returns Record<string, ModelStatic<AnyModel>>
- Defined in prorm.ts:1607

fdw

get fdw(): ForeignDataManager
Lazily-created ForeignDataManager instance for this Prorm connection. Provides the full FDW management surface (servers, user mappings, foreign tables).

Returns ForeignDataManager
Example
```
await prorm.fdw.createServer('remote_pg', { fdw: 'postgres_fdw', options: { host: 'db2.example.com', dbname: 'sales', port: '5432' } });
```
- Defined in prorm.ts:6377

users

get users(): UserManager
Lazily-created UserManager instance for this Prorm connection. Provides the full user / role / privilege management surface.

Returns UserManager
Example
```
await prorm.users.createUser('app', { host: '%', password: 'secret' });
```
- Defined in prorm.ts:6391

UUIDV4

get UUIDV4(): Literal

UUIDV4 default value for generating UUIDs Use as defaultValue in model definitions

Returns Literal

A Literal that generates a UUID v4

Example

const User = prorm.define('User', {
  id: { type: DataTypes.UUID, defaultValue: Prorm.UUIDV4, primaryKey: true },
  uuid: { type: DataTypes.UUID, defaultValue: prorm.UUIDV4 }
});

Methods

literal

literal(sql: string): Literal

Create a literal/raw SQL expression Use this to insert raw SQL into queries without parameter escaping

Parameters

sql: string
The raw SQL expression

Returns Literal

A Literal instance that can be used in queries

Example

// Use in default values
const User = prorm.define('User', {
  createdAt: { type: DATE, defaultValue: prorm.literal('NOW()') },
  updatedAt: { type: DATE, defaultValue: prorm.literal("strftime('%Y-%m-%d %H:%M:%S', 'now')") }
});

Example

// Use in updates (increment counter)
await User.update(
  { count: prorm.literal('count + 1') },
  { where: { id: 1 } }
);

Example

// Use in complex calculations in select
const users = await User.findAll({
  attributes: [
    'id',
    'name',
    [prorm.literal('price * quantity'), 'total']
  ]
});

Example

// Use in subqueries
const posts = await Post.findAll({
  where: {
    userId: prorm.literal('(SELECT id FROM users WHERE active = 1 LIMIT 1)')
  }
});

getPool

getPool(): DatabaseConnectionPool | null
Get the connection pool instance

Returns DatabaseConnectionPool | null
The connection pool or null if not configured
- Defined in prorm.ts:887

getPoolStats

getPoolStats(): | {
    size: number;
    available: number;
    inUse: number;
    pending: number;
}
| null
Get pool statistics

Returns { size: number; available: number; inUse: number; pending: number } | null
Pool statistics or null if pool not configured
- Defined in prorm.ts:895

getLogger

getLogger(): Logger
Get the logger instance

Returns Logger
- Defined in prorm.ts:915

setLoggingLevel

setLoggingLevel(level: "debug" | "info" | "warn" | "error"): void
Set logging level
Parameters
- level: "debug" | "info" | "warn" | "error"
Returns void
- Defined in prorm.ts:922

connect

connect(): Promise<void>
Connect to the database and authenticate

Returns Promise<void>
- Defined in prorm.ts:1153

close

close(): Promise<void>
Disconnect from the database and close the connection pool

Returns Promise<void>
- Defined in prorm.ts:1182

addHook

addHook(hookName: string, handler: HookCallback): this
Add a hook to the Prorm instance
Parameters
- hookName: string
  The name of the hook (e.g., 'beforeDefine', 'afterSync', 'beforeConnect')
- handler: HookCallback
  The hook handler function
Returns this
The Prorm instance for chaining
Example
```
prorm.addHook('beforeDefine', ({ modelName, attributes }) => {
  console.log('Defining model:', modelName);
});
```
Example
```
prorm.addHook('beforeConnect', async () => {
  console.log('About to connect to database');
});
```
- Defined in prorm.ts:1225

authenticate

authenticate(): Promise<void>
Authenticate the connection by running a test query

Returns Promise<void>
Promise that resolves if connection is successful
Throws
Error if connection fails
Example
```
await prorm.authenticate();
console.log('Connection OK');
```
- Defined in prorm.ts:1246

getDialect

getDialect(): string
Get the dialect name

Returns string
The dialect name (e.g., 'sqlite', 'postgres', 'mysql')
- Defined in prorm.ts:1278

getDialectInstance

getDialectInstance(): Dialect | null
Get the dialect instance

Returns Dialect | null
The dialect instance or null if not initialized
- Defined in prorm.ts:1286

getQueryInterface

getQueryInterface(): any
Get the query interface for DDL operations

Returns any
- Defined in prorm.ts:1293

createPartitionedTable

createPartitionedTable(
    tableName: string,
    columns: Record<string, ColumnDefinition>,
    options?: TableOptions & {
        partitionBy: {
            type: "range" | "list" | "hash";
            column: string | string[];
        };
        partitions?: {
            name: string;
            bound?: {
                from: string
                | number
                | Date;
                to?: string | number | Date;
                values?: ((...) | (...))[];
                modulus?: number;
                remainder?: number;
            };
            tablespace?: string;
            storageParameters?: Record<string, string | number>;
        }[];
    },
): Promise<void>
Create a partitioned table (PostgreSQL 10+)
Parameters
- tableName: string
  Name of the table to create
- columns: Record<string, ColumnDefinition>
  Column definitions
- Optionaloptions: TableOptions & {
      partitionBy: {
          type: "range" | "list" | "hash";
          column: string | string[];
      };
      partitions?: {
          name: string;
          bound?: {
              from: string
              | number
              | Date;
              to?: string | number | Date;
              values?: ((...) | (...))[];
              modulus?: number;
              remainder?: number;
          };
          tablespace?: string;
          storageParameters?: Record<string, string | number>;
      }[];
  }
  Table options including partition configuration
Returns Promise<void>
- Defined in prorm.ts:1307

createPartition

createPartition(
    options: {
        parentTable: string;
        name: string;
        bound?: {
            from: string | number | Date;
            to?: string | number | Date;
            values?: (string | number)[];
            modulus?: number;
            remainder?: number;
        };
        tablespace?: string;
        storageParameters?: Record<string, string | number>;
    },
): Promise<void>
Create a partition for an existing partitioned table (PostgreSQL 10+)
Parameters
- options: {
      parentTable: string;
      name: string;
      bound?: {
          from: string | number | Date;
          to?: string | number | Date;
          values?: (string | number)[];
          modulus?: number;
          remainder?: number;
      };
      tablespace?: string;
      storageParameters?: Record<string, string | number>;
  }
  Partition creation options
Returns Promise<void>
- Defined in prorm.ts:1340

attachPartition

attachPartition(
options: { parentTable: string; partitionName: string },
): Promise<void>
Attach a partition to a partitioned table (PostgreSQL 11+)
Parameters
- options: { parentTable: string; partitionName: string }
  Partition attachment options
Returns Promise<void>
- Defined in prorm.ts:1364

detachPartition

detachPartition(
options: { partitionName: string; validate?: boolean },
): Promise<void>
Detach a partition from a partitioned table (PostgreSQL 11+)
Parameters
- options: { partitionName: string; validate?: boolean }
  Partition detachment options
Returns Promise<void>
- Defined in prorm.ts:1379

dropPartition

dropPartition(
partitionName: string,
options?: { ifExists?: boolean; cascade?: boolean },
): Promise<void>
Drop a partition (PostgreSQL 10+)
Parameters
- partitionName: string
  Name of the partition to drop
- Optionaloptions: { ifExists?: boolean; cascade?: boolean }
  Drop options
Returns Promise<void>
- Defined in prorm.ts:1395

disableForeignKeyChecks

disableForeignKeyChecks(): Promise<void>
Disable foreign key checks for the current session

On PostgreSQL this issues SET session_replication_role = 'replica', which needs superuser or a role granted SET ON PARAMETER session_replication_role (PostgreSQL 15+).

Returns Promise<void>
Promise that resolves when foreign key checks are disabled

Throws
on dialects with no session-level switch (SQL Server, Oracle and Db2 are per-table; Redshift, Snowflake and ClickHouse never enforce foreign keys).
- Defined in prorm.ts:1420

enableForeignKeyChecks

enableForeignKeyChecks(): Promise<void>
Enable foreign key checks for the current session

The inverse of disableForeignKeyChecks, with the same dialect support and the same PostgreSQL privilege requirement.

Returns Promise<void>
Promise that resolves when foreign key checks are enabled

Throws
on dialects with no session-level switch
- Defined in prorm.ts:1434

setIsolationLevel

setIsolationLevel(
    level:
        | "SERIALIZABLE"
        | "READ_UNCOMMITTED"
        | "READ_COMMITTED"
        | "REPEATABLE_READ",
): Promise<void>
Set the transaction isolation level
Parameters
- level: "SERIALIZABLE" | "READ_UNCOMMITTED" | "READ_COMMITTED" | "REPEATABLE_READ"
  The isolation level to set
Returns Promise<void>
Promise that resolves when the isolation level is set
- Defined in prorm.ts:1443

getDisableForeignKeyChecksSQL

getDisableForeignKeyChecksSQL(): string
Get SQL for disabling foreign key checks for the current dialect

Routing lives in sql-constants.getForeignKeyChecksSQL so that the three mutually incompatible statements (SQLite's PRAGMA, MySQL's session variable, PostgreSQL's session_replication_role) are chosen from one table. This used to fall through to MySQL syntax for every dialect it did not name - PostgreSQL included - so disableForeignKeyChecks() threw a syntax error at the server on most of the supported databases.

Returns string
SQL string for disabling foreign key checks

Throws
when the dialect has no session-level equivalent
- Defined in prorm.ts:1472

getEnableForeignKeyChecksSQL

getEnableForeignKeyChecksSQL(): string
Get SQL for enabling foreign key checks for the current dialect

Returns string
SQL string for enabling foreign key checks

Throws
when the dialect has no session-level equivalent
- Defined in prorm.ts:1483

getSetIsolationLevelSQL

getSetIsolationLevelSQL(
    level:
        | "SERIALIZABLE"
        | "READ_UNCOMMITTED"
        | "READ_COMMITTED"
        | "REPEATABLE_READ",
): string
Get SQL for setting transaction isolation level for the current dialect
Parameters
- level: "SERIALIZABLE" | "READ_UNCOMMITTED" | "READ_COMMITTED" | "REPEATABLE_READ"
  The isolation level
Returns string
SQL string for setting the isolation level
- Defined in prorm.ts:1492

disableUniqueKeyChecks

disableUniqueKeyChecks(): Promise<void>
Disable unique key checks for the current session (MySQL/MariaDB only)

The no-op on other dialects is deliberate, and is not the same situation as the foreign key switch above. SET UNIQUE_CHECKS is a MySQL/MariaDB optimisation hint: it defers uniqueness verification on InnoDB secondary indexes during bulk loads. No other supported database has a session setting that suspends unique constraint checking - PostgreSQL's session_replication_role = 'replica' suppresses triggers and foreign keys but still enforces unique indexes - so there is nothing to translate it to. Skipping the statement leaves the database in exactly the state the caller already had (uniqueness enforced), which is safe; throwing would break the common disableUniqueKeyChecks(); bulkCreate(); enable...() bulk-load pattern on every non-MySQL dialect for no benefit.

Returns Promise<void>
Promise that resolves when unique key checks are disabled
- Defined in prorm.ts:1520

enableUniqueKeyChecks

enableUniqueKeyChecks(): Promise<void>
Enable unique key checks for the current session (MySQL/MariaDB only)

A no-op elsewhere, for the reason given on disableUniqueKeyChecks.

Returns Promise<void>
Promise that resolves when unique key checks are enabled
- Defined in prorm.ts:1535

getSQLConstants

getSQLConstants(): object
Get SQL constants for the current dialect

Returns object
SQL constants for the current dialect
- Defined in prorm.ts:1547

getDatabase

getDatabase(): string
Get the database name

Returns string
The database name from the configuration
- Defined in prorm.ts:1569

getHost

getHost(): string
Get the host name

Returns string
The host from the configuration
- Defined in prorm.ts:1577

getPort

getPort(): string | number
Get the port number

Returns string | number
The port from the configuration
- Defined in prorm.ts:1585

getUsername

getUsername(): string
Get the username

Returns string
The username from the configuration
- Defined in prorm.ts:1593

getModels

getModels(): Map<string, ModelStatic<any>>
Get all registered models

Returns Map<string, ModelStatic<any>>
- Defined in prorm.ts:1600

model

model(name: string): ModelStatic<any> | undefined
Get a model by name
Parameters
- name: string
Returns ModelStatic<any> | undefined
- Defined in prorm.ts:1614

getModel

getModel(modelName: string): ModelStatic<any> | undefined
Get a model by name (alias for model())
Parameters
- modelName: string
  The name of the model to retrieve
Returns ModelStatic<any> | undefined
The model static or undefined if not found
Example
```
const User = prorm.getModel('User');
```
- Defined in prorm.ts:1626

hasModel

hasModel(modelName: string): boolean
Check if a model is registered with Prorm
Parameters
- modelName: string
  The name of the model to check
Returns boolean
True if the model is registered, false otherwise
Example
```
const hasUser = prorm.hasModel('User');
```
- Defined in prorm.ts:1638

getTableName

getTableName(model: string | ModelStatic<any>): string
Get the table name for a model, including schema if defined
Parameters
- model: string | ModelStatic<any>
  The model to get the table name for
Returns string
The full table name with schema (e.g., "schema.tableName" or just "tableName")
- Defined in prorm.ts:1647

tableExists

tableExists(tableName: string): Promise<boolean>
Check if a table exists in the database
Parameters
- tableName: string
  The table name to check (can include schema for PostgreSQL)
Returns Promise<boolean>
True if the table exists, false otherwise
- Defined in prorm.ts:1672

createMaterializedView

createMaterializedView(
    options: {
        name: string;
        definition?: ViewDefinition;
        query?: string;
        schema?: string;
        ifNotExists?: boolean;
        replace?: boolean;
        withData?: boolean;
        uniqueIndex?: string;
        comment?: string;
    },
): Promise<void>
Create a materialized view (PostgreSQL only)
Parameters
- options: {
      name: string;
      definition?: ViewDefinition;
      query?: string;
      schema?: string;
      ifNotExists?: boolean;
      replace?: boolean;
      withData?: boolean;
      uniqueIndex?: string;
      comment?: string;
  }
  Materialized view options
  - name: string
  - Optionaldefinition?: ViewDefinition
    
    What the view selects, as query options. Preferred over query: the SELECT is built for the connected dialect instead of written by hand.
  - Optionalquery?: string
    
    Deprecated
    Prefer definition.
  - Optionalschema?: string
  - OptionalifNotExists?: boolean
  - Optionalreplace?: boolean
  - OptionalwithData?: boolean
  - OptionaluniqueIndex?: string
  - Optionalcomment?: string
Returns Promise<void>
Promise
Example
```
await prorm.createMaterializedView({
  name: 'user_stats',
  definition: {
    from: Order,
    attributes: ['userId', [fn('COUNT', col('id')), 'orderCount']],
    group: 'userId',
  },
  uniqueIndex: 'user_stats_user_id_key',
});
```
- Defined in prorm.ts:1705

refreshMaterializedView

refreshMaterializedView(
viewName: string,
options?: { concurrently?: boolean; withNoData?: boolean },
): Promise<void>
Refresh a materialized view (PostgreSQL only)
Parameters
- viewName: string
  Name of the materialized view to refresh
- Optionaloptions: { concurrently?: boolean; withNoData?: boolean }
  Refresh options
Returns Promise<void>
Promise
Example
```
// Simple refresh
await prorm.refreshMaterializedView('user_stats');

// Concurrent refresh (requires unique index)
await prorm.refreshMaterializedView('user_stats', { concurrently: true });

// Refresh without data
await prorm.refreshMaterializedView('user_stats', { withNoData: true });
```
- Defined in prorm.ts:1769

dropMaterializedView

dropMaterializedView(
viewName: string,
options?: { ifExists?: boolean; cascade?: boolean },
): Promise<void>
Drop a materialized view (PostgreSQL only)
Parameters
- viewName: string
  Name of the materialized view to drop
- Optionaloptions: { ifExists?: boolean; cascade?: boolean }
  Drop options
Returns Promise<void>
Promise
Example
```
await prorm.dropMaterializedView('user_stats');
await prorm.dropMaterializedView('user_stats', { ifExists: true, cascade: true });
```
- Defined in prorm.ts:1794

hasMaterializedView

hasMaterializedView(viewName: string): Promise<boolean>
Check if a materialized view exists (PostgreSQL only)
Parameters
- viewName: string
  Name of the materialized view
Returns Promise<boolean>
True if the materialized view exists
Example
```
const exists = await prorm.hasMaterializedView('user_stats');
```
- Defined in prorm.ts:1817

showMaterializedViews

showMaterializedViews(): Promise<string[]>
Show all materialized views in the database (PostgreSQL only)

Returns Promise<string[]>
Array of materialized view names
Example
```
const views = await prorm.showMaterializedViews();
```
- Defined in prorm.ts:1836

define

define<T = any>(
    modelName: string,
    attributes: Record<string, AttributeOptions>,
    options?: ModelOptions,
): ModelStatic<any>
Define a new model
Type Parameters
- T = any
Parameters
- modelName: string
  Name of the model
- attributes: Record<string, AttributeOptions>
  Model attributes
- options: ModelOptions = {}
  Model options
Returns ModelStatic<any>
- Defined in prorm.ts:1854

addModel

addModel<T = any>(modelClass: new () => T): ModelStatic<any>

Add a model defined with decorators

Type Parameters

T = any

Parameters

modelClass: new () => T
The model class (decorated with @Table)

Returns ModelStatic<any>

The registered model

Example

import { Model, DataTypes } from 'orm';
import { Table, Column, PrimaryKey, AutoIncrement } from 'orm/decorators';

@Table({ tableName: 'users' })
export class User extends Model {
  @Column(DataTypes.INTEGER)
  @PrimaryKey
  @AutoIncrement
  declare id: number;

  @Column(DataTypes.STRING)
  declare name: string;
}

prorm.addModel(User);

query

query(
sql: string,
options?: QueryOptions,
): Promise<number | unknown[] | [unknown[], boolean]>

Execute a raw query

Parameters

sql: string
The SQL query string with optional placeholders
Optionaloptions: QueryOptions
Query options including replacements

Returns Promise<number | unknown[] | [unknown[], boolean]>

Query results (array for SELECT, [rows, created] for INSERT, count for UPDATE/DELETE)

Example

// Named replacements
await prorm.query('SELECT * FROM users WHERE status = :status', {
  replacements: { status: 'active' }
});

Example

// IN clause with array replacement
await prorm.query('SELECT * FROM users WHERE id IN (:ids)', {
  replacements: { ids: [1, 2, 3] }
});

Example

// Positional replacements
await prorm.query('SELECT * FROM users WHERE name = ?', {
  replacements: ['john']
});

Example

// Map raw results to model instances
const users = await prorm.query('SELECT * FROM users', {
  model: User,
  mapToModel: true
});
// Returns ModelInstance objects instead of plain objects

createSavepoint

createSavepoint(name?: string, options?: QueryOptions): Promise<string>
Create a savepoint within a transaction
Parameters
- Optionalname: string
  Optional savepoint name
- Optionaloptions: QueryOptions
  Query options including transaction
Returns Promise<string>
The savepoint name
- Defined in prorm.ts:5832

releaseSavepoint

releaseSavepoint(name: string, options?: QueryOptions): Promise<void>
Release a savepoint
Parameters
- name: string
  Savepoint name to release
- Optionaloptions: QueryOptions
  Query options including transaction
Returns Promise<void>
- Defined in prorm.ts:5847

rollbackToSavepoint

rollbackToSavepoint(name: string, options?: QueryOptions): Promise<void>
Rollback to a savepoint
Parameters
- name: string
  Savepoint name to rollback to
- Optionaloptions: QueryOptions
  Query options including transaction
Returns Promise<void>
- Defined in prorm.ts:5860

queryWithMetadata

queryWithMetadata(sql: string, options?: QueryOptions): Promise<RawQueryResult>
Execute a raw query and return structured result
Parameters
- sql: string
  The SQL query string with optional placeholders
- Optionaloptions: QueryOptions
  Query options including replacements
Returns Promise<RawQueryResult>
Structured result with rows, count, and isSelect flag
- Defined in prorm.ts:5874

transaction

transaction<T>(
    callbackOrOptions?:
        | TransactionOptions
        | ((transaction: any) => Promise<T>),
    options?: TransactionOptions,
): Promise<any>
Execute a query within a transaction (callback mode) or return a transaction object (manual mode).

Callback mode: prorm.transaction(async (t) => { ... }) Manual mode: const t = await prorm.transaction(); await t.commit();
Type Parameters
- T
Parameters
- OptionalcallbackOrOptions: TransactionOptions | ((transaction: any) => Promise<T>)
- Optionaloptions: TransactionOptions
Returns Promise<any>
- Defined in prorm.ts:5907

getTransaction

getTransaction(): Transaction | null
Get the current transaction

Returns Transaction | null
- Defined in prorm.ts:6027

setTransaction

setTransaction(transaction: Transaction | null): void
Set the current transaction
Parameters
- transaction: Transaction | null
Returns void
- Defined in prorm.ts:6034

beforeDefine

beforeDefine(callback: HookCallback): void
Register a hook to be called before a model is defined
Parameters
- callback: HookCallback
  Function to call before model definition
Returns void
Example
```
prorm.beforeDefine((model, attributes, options) => {
  console.log('Defining:', model.name);
});
```
- Defined in prorm.ts:6049

afterDefine

afterDefine(callback: HookCallback): void
Register a hook to be called after a model is defined
Parameters
- callback: HookCallback
  Function to call after model definition
Returns void
Example
```
prorm.afterDefine((model) => {
  console.log('Defined:', model.name);
});
```
- Defined in prorm.ts:6062

beforeSync

beforeSync(callback: HookCallback): void
Register a hook to be called before sync
Parameters
- callback: HookCallback
  Function to call before sync
Returns void
Example
```
prorm.beforeSync((options) => {
  console.log('About to sync with options:', options);
});
```
- Defined in prorm.ts:6075

afterSync

afterSync(callback: HookCallback): void
Register a hook to be called after sync
Parameters
- callback: HookCallback
  Function to call after sync
Returns void
Example
```
prorm.afterSync((options) => {
  console.log('Sync complete with options:', options);
});
```
- Defined in prorm.ts:6088

beforeConnect

beforeConnect(callback: HookCallback): void
Register a hook to be called before connection
Parameters
- callback: HookCallback
  Function to call before connecting
Returns void
Example
```
prorm.beforeConnect(() => {
  console.log('About to connect to database');
});
```
- Defined in prorm.ts:6101

afterConnect

afterConnect(callback: HookCallback): void
Register a hook to be called after connection
Parameters
- callback: HookCallback
  Function to call after connecting, receives connection object
Returns void
Example
```
prorm.afterConnect((connection) => {
  console.log('Connected to database', connection.id);
});
```
- Defined in prorm.ts:6114

beforeDisconnect

beforeDisconnect(callback: HookCallback): void
Register a hook to be called before disconnection
Parameters
- callback: HookCallback
  Function to call before disconnecting, receives connection object
Returns void
Example
```
prorm.beforeDisconnect((connection) => {
  console.log('About to disconnect', connection.id);
});
```
- Defined in prorm.ts:6127

afterDisconnect

afterDisconnect(callback: HookCallback): void
Register a hook to be called after disconnection
Parameters
- callback: HookCallback
  Function to call after disconnecting, receives connection object
Returns void
Example
```
prorm.afterDisconnect((connection) => {
  console.log('Disconnected from database', connection.id);
});
```
- Defined in prorm.ts:6140

beforeDestroy

beforeDestroy(callback: HookCallback): void
Register a hook to be called before destroy
Parameters
- callback: HookCallback
  Function to call before destroy
Returns void
Example
```
prorm.beforeDestroy((options) => {
  console.log('About to destroy records');
});
```
- Defined in prorm.ts:6153

afterDestroy

afterDestroy(callback: HookCallback): void
Register a hook to be called after destroy
Parameters
- callback: HookCallback
  Function to call after destroy
Returns void
Example
```
prorm.afterDestroy((options) => {
  console.log('Records destroyed');
});
```
- Defined in prorm.ts:6166

beforeUpsert

beforeUpsert(callback: HookCallback): void
Register a hook to be called before upsert
Parameters
- callback: HookCallback
  Function to call before upsert
Returns void
Example
```
prorm.beforeUpsert((options) => {
  console.log('About to upsert record');
});
```
- Defined in prorm.ts:6179

afterUpsert

afterUpsert(callback: HookCallback): void
Register a hook to be called after upsert
Parameters
- callback: HookCallback
  Function to call after upsert
Returns void
Example
```
prorm.afterUpsert((options) => {
  console.log('Record upserted');
});
```
- Defined in prorm.ts:6192

beforeReload

beforeReload(callback: HookCallback): void
Register a hook to be called before reload
Parameters
- callback: HookCallback
  Function to call before reload
Returns void
Example
```
prorm.beforeReload((options) => {
  console.log('About to reload record');
});
```
- Defined in prorm.ts:6205

showTables

showTables(): Promise<string[]>
Show all tables

Returns Promise<string[]>
- Defined in prorm.ts:6212

showAllSchemas

showAllSchemas(): Promise<string[]>
Alias for showSchemas - Show all schemas For PostgreSQL, returns all schemas in the database For MySQL/MariaDB, returns all databases For SQLite, returns ['main']

Returns Promise<string[]>
- Defined in prorm.ts:6226

createExtension

createExtension(
extensionName: string,
options?: CreateExtensionOptions,
): Promise<void>
Create a PostgreSQL extension
Parameters
- extensionName: string
  Name of the extension to create (e.g., 'uuid-ossp', 'postgis', 'pg_trgm')
- Optionaloptions: CreateExtensionOptions
  Extension options (ifNotExists, schema, version)
Returns Promise<void>
Promise that resolves when the extension is created
Example
```
// Create the uuid-ossp extension for UUID generation
await prorm.createExtension('uuid-ossp');
```
Example
```
// Create PostGIS extension for spatial data
await prorm.createExtension('postgis', { ifNotExists: true });
```
Example
```
// Create pg_trgm extension with specific version
await prorm.createExtension('pg_trgm', { version: '1.5' });
```
- Defined in prorm.ts:6248

dropExtension

dropExtension(
extensionName: string,
options?: DropExtensionOptions,
): Promise<void>
Drop a PostgreSQL extension
Parameters
- extensionName: string
  Name of the extension to drop
- Optionaloptions: DropExtensionOptions
  Drop options (ifExists, cascade)
Returns Promise<void>
Promise that resolves when the extension is dropped
Example
```
// Drop an extension
await prorm.dropExtension('uuid-ossp');
```
Example
```
// Drop extension with cascade (drops dependent objects)
await prorm.dropExtension('postgis', { cascade: true });
```
- Defined in prorm.ts:6279

getExtensions

getExtensions(): Promise<ExtensionInfo[]>

Get all installed PostgreSQL extensions

Returns Promise<ExtensionInfo[]>

Promise that resolves to an array of extension information

Example

const extensions = await prorm.getExtensions();
console.log(extensions);
// Output: [
//   { name: 'uuid-ossp', defaultVersion: null, installedVersion: '1.0', comment: null },
//   { name: 'pg_trgm', defaultVersion: null, installedVersion: '1.5', comment: null }
// ]

hasExtension

hasExtension(extensionName: string): Promise<boolean>
Check if a PostgreSQL extension is installed
Parameters
- extensionName: string
  Name of the extension to check
Returns Promise<boolean>
Promise that resolves to true if the extension is installed
Example
```
const hasUuid = await prorm.hasExtension('uuid-ossp');
if (hasUuid) {
  console.log('UUID extension is available');
}
```
- Defined in prorm.ts:6335

extensionExists

extensionExists(extensionName: string): Promise<boolean>
Check if a PostgreSQL extension is installed (alias for hasExtension). Returns false for non-PostgreSQL dialects instead of throwing.
Parameters
- extensionName: string
Returns Promise<boolean>
- Defined in prorm.ts:6355

createUser

createUser(username: string, options?: any): Promise<void>
Parameters
- username: string
- Optionaloptions: any
Returns Promise<void>
- Defined in prorm.ts:6400

alterUser

alterUser(username: string, options: any): Promise<void>
Parameters
- username: string
- options: any
Returns Promise<void>
- Defined in prorm.ts:6404

dropUser

dropUser(username: string, options?: any): Promise<void>
Parameters
- username: string
- Optionaloptions: any
Returns Promise<void>
- Defined in prorm.ts:6408

getUsers

getUsers(): Promise<UserInfo[]>
Returns Promise<UserInfo[]>
- Defined in prorm.ts:6412

userExists

userExists(username: string, host?: string): Promise<boolean>
Parameters
- username: string
- Optionalhost: string
Returns Promise<boolean>
- Defined in prorm.ts:6416

grant

grant(options: any): Promise<void>
Parameters
- options: any
Returns Promise<void>
- Defined in prorm.ts:6420

revoke

revoke(options: any): Promise<void>
Parameters
- options: any
Returns Promise<void>
- Defined in prorm.ts:6424

grantRole

grantRole(role: string, to: string | string[], options?: any): Promise<void>
Parameters
- role: string
- to: string | string[]
- Optionaloptions: any
Returns Promise<void>
- Defined in prorm.ts:6428

revokeRole

revokeRole(role: string, from: string | string[], options?: any): Promise<void>
Parameters
- role: string
- from: string | string[]
- Optionaloptions: any
Returns Promise<void>
- Defined in prorm.ts:6432

createRole

createRole(roleName: string, options?: any): Promise<void>
Parameters
- roleName: string
- Optionaloptions: any
Returns Promise<void>
- Defined in prorm.ts:6436

dropRole

dropRole(roleName: string, options?: any): Promise<void>
Parameters
- roleName: string
- Optionaloptions: any
Returns Promise<void>
- Defined in prorm.ts:6440

flushPrivileges

flushPrivileges(): Promise<void>
Returns Promise<void>
- Defined in prorm.ts:6444

showGrants

showGrants(username: string, host?: string): Promise<any[]>
Parameters
- username: string
- Optionalhost: string
Returns Promise<any[]>
- Defined in prorm.ts:6448

getRoles

getRoles(): Promise<string[]>
Returns Promise<string[]>
- Defined in prorm.ts:6452

createServer

createServer(name: string, options: ForeignServerOptions): Promise<void>
CREATE FOREIGN SERVER shortcut.
Parameters
- name: string
- options: ForeignServerOptions
Returns Promise<void>
Example
```
await prorm.createServer('remote_pg', {
  fdw: 'postgres_fdw',
  options: { host: 'remotehost', dbname: 'remotedb', port: '5432' },
  ifNotExists: true,
});
```
- Defined in prorm.ts:6466

dropServer

dropServer(
name: string,
options?: { ifExists?: boolean; cascade?: boolean },
): Promise<void>
DROP FOREIGN SERVER shortcut.
Parameters
- name: string
- Optionaloptions: { ifExists?: boolean; cascade?: boolean }
Returns Promise<void>
- Defined in prorm.ts:6474

getServers

getServers(): Promise<ServerInfo[]>
List all foreign servers visible in the current PostgreSQL database.

Returns Promise<ServerInfo[]>
- Defined in prorm.ts:6485

createUserMapping

createUserMapping(options: UserMappingOptions): Promise<void>
CREATE USER MAPPING shortcut.
Parameters
- options: UserMappingOptions
Returns Promise<void>
Example
```
await prorm.createUserMapping({
  serverName: 'remote_pg',
  user: 'CURRENT_USER',
  options: { user: 'remoteuser', password: 'secret' },
});
```
- Defined in prorm.ts:6500

dropUserMapping

dropUserMapping(serverName: string, user?: string): Promise<void>
DROP USER MAPPING shortcut.
Parameters
- serverName: string
- Optionaluser: string
Returns Promise<void>
- Defined in prorm.ts:6508

createForeignTable

createForeignTable(
tableName: string,
options: ForeignTableOptions,
): Promise<void>

CREATE FOREIGN TABLE shortcut.

Parameters

tableName: string
options: ForeignTableOptions

Returns Promise<void>

Example

await prorm.createForeignTable('remote_orders', {
  serverName: 'remote_pg',
  columns: {
    id:         { type: 'INTEGER' },
    total:      { type: 'NUMERIC(12,2)' },
    created_at: { type: 'TIMESTAMP' },
  },
  options: { schema_name: 'public', table_name: 'orders' },
});

importForeignSchema

importForeignSchema(
    remoteSchema: string,
    serverName: string,
    options?: ImportForeignSchemaOptions,
): Promise<void>
IMPORT FOREIGN SCHEMA shortcut.
Parameters
- remoteSchema: string
- serverName: string
- Optionaloptions: ImportForeignSchemaOptions
Returns Promise<void>
Example
```
await prorm.importForeignSchema('public', 'remote_pg', {
  localSchema: 'remote_mirror',
  limitTo: ['users', 'orders'],
});
```
- Defined in prorm.ts:6541

defineForeignTable

defineForeignTable(
tableName: string,
options: ForeignTableOptions,
): Promise<any>
Define a foreign table and register a read-only model for it.

Works like define() but issues CREATE FOREIGN TABLE in the database and returns a model whose findAll / findOne / findByPk are usable for read-only queries. Write operations (create/update/destroy) are not prevented at the ORM level but will fail at the database level because PostgreSQL foreign tables are read-only by default.
Parameters
- tableName: string
  The local foreign table name
- options: ForeignTableOptions
  Foreign table options (serverName, columns, etc.)
Returns Promise<any>
The model class registered under tableName
Example
```
const RemoteUser = await prorm.defineForeignTable('remote_users', {
  serverName: 'remote_pg',
  columns: {
    id:    { type: 'INTEGER' },
    email: { type: 'TEXT' },
    name:  { type: 'VARCHAR(255)' },
  },
  ifNotExists: true,
});
const users = await RemoteUser.findAll({ where: { name: 'Alice' } });
```
- Defined in prorm.ts:6575

getDatabaseVersion

getDatabaseVersion(): Promise<string>
Get database version

Returns Promise<string>
- Defined in prorm.ts:6602

getDatabaseName

getDatabaseName(): string
Get database name

Returns string
- Defined in prorm.ts:6613

createSchema

createSchema(name: string): Promise<void>
Create a database schema
Parameters
- name: string
  Name of the schema to create
Returns Promise<void>
Promise that resolves when the schema is created
Example
```
// Create a new schema
await prorm.createSchema('mySchema');
```
- Defined in prorm.ts:6635

dropSchema

dropSchema(
name: string,
options?: { cascade?: boolean; ifExists?: boolean },
): Promise<void>
Drop a database schema
Parameters
- name: string
  Name of the schema to drop
- Optionaloptions: { cascade?: boolean; ifExists?: boolean }
  Options for dropping the schema (cascade, ifExists)
Returns Promise<void>
Promise that resolves when the schema is dropped
Example
```
// Drop a schema
await prorm.dropSchema('mySchema');
```
Example
```
// Drop schema with cascade (drop all objects in schema)
await prorm.dropSchema('mySchema', { cascade: true });
```
- Defined in prorm.ts:6671

showSchemas

showSchemas(): Promise<string[]>
Show all schemas

Returns Promise<string[]>
Promise that resolves to an array of schema names
Example
```
// Get all schemas
const schemas = await prorm.showSchemas();
console.log(schemas); // ['public', 'mySchema', ...]
```
- Defined in prorm.ts:6714

getTableNameWithSchema

getTableNameWithSchema(
    tableName: string,
    schema?: string,
    schemaDelimiter?: string,
): string
Get the full table name with schema prefix
Parameters
- tableName: string
  The table name
- Optionalschema: string
  Optional schema name
- OptionalschemaDelimiter: string
  Optional delimiter (default: '.')
Returns string
Full table name with schema prefix
- Defined in prorm.ts:6745

createTrigger

createTrigger(
    options: {
        tableName: string;
        triggerName: string;
        timing: "BEFORE" | "AFTER" | "INSTEAD OF";
        event:
            | "INSERT"
            | "UPDATE"
            | "DELETE"
            | "INSERT UPDATE"
            | "INSERT DELETE"
            | "UPDATE DELETE"
            | "INSERT UPDATE DELETE";
        body: string;
        schema?: string;
        rowLevel?: boolean;
        constraint?: string;
        updateColumns?: string[];
        functionName?: string;
        functionArgs?: any[];
    },
): Promise<void>
Create a database trigger
Parameters
- options: {
      tableName: string;
      triggerName: string;
      timing: "BEFORE" | "AFTER" | "INSTEAD OF";
      event:
          | "INSERT"
          | "UPDATE"
          | "DELETE"
          | "INSERT UPDATE"
          | "INSERT DELETE"
          | "UPDATE DELETE"
          | "INSERT UPDATE DELETE";
      body: string;
      schema?: string;
      rowLevel?: boolean;
      constraint?: string;
      updateColumns?: string[];
      functionName?: string;
      functionArgs?: any[];
  }
  Trigger creation options
Returns Promise<void>
Promise that resolves when the trigger is created
Example
```
// Create an INSERT trigger in PostgreSQL
await prorm.createTrigger({
  tableName: 'users',
  triggerName: 'set_created_at',
  timing: 'BEFORE',
  event: 'INSERT',
  body: 'NEW.created_at = NOW();',
  rowLevel: true
});
```
Example
```
// Create an UPDATE trigger in MySQL
await prorm.createTrigger({
  tableName: 'users',
  triggerName: 'update_timestamp',
  timing: 'BEFORE',
  event: 'UPDATE',
  body: 'SET NEW.updated_at = NOW();'
});
```
- Defined in prorm.ts:6779

dropTrigger

dropTrigger(
    options: {
        tableName: string;
        triggerName: string;
        schema?: string;
        ifExists?: boolean;
        cascade?: boolean;
        constraint?: boolean;
    },
): Promise<void>
Drop a database trigger
Parameters
- options: {
      tableName: string;
      triggerName: string;
      schema?: string;
      ifExists?: boolean;
      cascade?: boolean;
      constraint?: boolean;
  }
  Trigger drop options
Returns Promise<void>
Promise that resolves when the trigger is dropped
Example
```
// Drop a trigger
await prorm.dropTrigger({
  tableName: 'users',
  triggerName: 'set_created_at'
});
```
Example
```
// Drop trigger with IF EXISTS (PostgreSQL)
await prorm.dropTrigger({
  tableName: 'users',
  triggerName: 'old_trigger',
  ifExists: true
});
```
- Defined in prorm.ts:6895

createAlgorithm

createAlgorithm(
    options: {
        name: string;
        arguments: string[];
        stateType: string;
        stateFunction: string;
        finalFunction?: string;
        initialCondition?: string;
        schema?: string;
        replace?: boolean;
        parallel?: "UNSAFE" | "SAFE" | "RESTRICTED";
        language?: string;
    },
): Promise<void>
Create a custom aggregate function (algorithm) in PostgreSQL PostgreSQL supports creating custom aggregate functions using CREATE AGGREGATE
Parameters
- options: {
      name: string;
      arguments: string[];
      stateType: string;
      stateFunction: string;
      finalFunction?: string;
      initialCondition?: string;
      schema?: string;
      replace?: boolean;
      parallel?: "UNSAFE" | "SAFE" | "RESTRICTED";
      language?: string;
  }
  Algorithm creation options
  - name: string
    
    Name of the aggregate function to create
  - arguments: string[]
    
    Input data types for the aggregate
  - stateType: string
    
    The state type (intermediate state data type)
  - stateFunction: string
    
    The state transition function body
  - OptionalfinalFunction?: string
    
    The final function body (optional)
  - OptionalinitialCondition?: string
    
    The initial condition value (optional)
  - Optionalschema?: string
    
    Schema name (optional)
  - Optionalreplace?: boolean
    
    If true, replaces existing aggregate (PostgreSQL 9.5+)
  - Optionalparallel?: "UNSAFE" | "SAFE" | "RESTRICTED"
    
    Parallel mode: UNSAFE, SAFE, or RESTRICTED
  - Optionallanguage?: string
    
    Language for the function (default: sql)
Returns Promise<void>
Promise that resolves when the algorithm is created
Example
```
// Create a custom aggregate function in PostgreSQL
await prorm.createAlgorithm({
  name: 'my_aggregate',
  arguments: ['integer'],
  stateType: 'integer',
  stateFunction: 's = s + $1',
  finalFunction: 's = s'
});
```
Example
```
// Create a custom aggregate with multiple parameters
await prorm.createAlgorithm({
  name: 'weighted_avg',
  arguments: ['numeric', 'numeric'],
  stateType: 'numeric',
  stateFunction: 's = s + ($1 * $2)',
  finalFunction: 's = s'
});
```
- Defined in prorm.ts:6971

dropAlgorithm

dropAlgorithm(
    options: {
        name: string;
        arguments: string[];
        schema?: string;
        ifExists?: boolean;
        cascade?: boolean;
        restrict?: boolean;
    },
): Promise<void>
Drop a custom aggregate function (algorithm) from PostgreSQL
Parameters
- options: {
      name: string;
      arguments: string[];
      schema?: string;
      ifExists?: boolean;
      cascade?: boolean;
      restrict?: boolean;
  }
  Algorithm drop options
  - name: string
    
    Name of the aggregate function to drop
  - arguments: string[]
    
    Input data types for the aggregate
  - Optionalschema?: string
    
    Schema name (optional)
  - OptionalifExists?: boolean
    
    If true, uses IF EXISTS (PostgreSQL 9.3+)
  - Optionalcascade?: boolean
    
    If true, CASCADE dependent objects
  - Optionalrestrict?: boolean
    
    If true, RESTRICT if dependent objects exist
Returns Promise<void>
Promise that resolves when the algorithm is dropped
Example
```
// Drop an algorithm
await prorm.dropAlgorithm({
  name: 'my_aggregate',
  arguments: ['integer']
});
```
Example
```
// Drop algorithm with IF EXISTS
await prorm.dropAlgorithm({
  name: 'my_aggregate',
  arguments: ['integer'],
  ifExists: true
});
```
- Defined in prorm.ts:7076

addColumn

addColumn(
    tableName: string,
    columnName: string,
    attribute: AttributeOptions,
): Promise<void>
Add a new column to a table
Parameters
- tableName: string
- columnName: string
- attribute: AttributeOptions
Returns Promise<void>
- Defined in prorm.ts:7122

removeColumn

removeColumn(tableName: string, columnName: string): Promise<void>
Remove a column from a table
Parameters
- tableName: string
- columnName: string
Returns Promise<void>
- Defined in prorm.ts:7158

changeColumn

changeColumn(
    tableName: string,
    columnName: string,
    attribute: AttributeOptions,
): Promise<void>
Change a column definition
Parameters
- tableName: string
- columnName: string
- attribute: AttributeOptions
Returns Promise<void>
- Defined in prorm.ts:7169

renameTable

renameTable(oldName: string, newName: string): Promise<void>
Rename a table
Parameters
- oldName: string
- newName: string
Returns Promise<void>
- Defined in prorm.ts:7198

addIndex

addIndex(
    tableName: string,
    indexName: string,
    fields: string[],
    options?: { unique?: boolean; type?: string },
): Promise<void>
Add an index
Parameters
- tableName: string
- indexName: string
- fields: string[]
- Optionaloptions: { unique?: boolean; type?: string }
Returns Promise<void>
- Defined in prorm.ts:7209

removeIndex

removeIndex(tableName: string, indexName: string): Promise<void>
Remove an index
Parameters
- tableName: string
- indexName: string
Returns Promise<void>
- Defined in prorm.ts:7225

describeTable

describeTable(tableName: string): Promise<Record<string, unknown>>
Describe a table
Parameters
- tableName: string
Returns Promise<Record<string, unknown>>
- Defined in prorm.ts:7236

createDatabase

createDatabase(
    options: {
        name: string;
        encoding?: string;
        lcCollate?: string;
        lcCtype?: string;
        template?: string;
        tablespace?: string;
        collate?: string;
        isTemplate?: boolean;
    },
): Promise<void>
Create a new database with the specified options. Supports PostgreSQL, MySQL, and MariaDB.
Parameters
- options: {
      name: string;
      encoding?: string;
      lcCollate?: string;
      lcCtype?: string;
      template?: string;
      tablespace?: string;
      collate?: string;
      isTemplate?: boolean;
  }
Returns Promise<void>
Example
```
// Create database with PostgreSQL
await prorm.createDatabase({
  name: 'myapp',
  encoding: 'UTF8',
  lcCollate: 'en_US.UTF-8',
  lcCtype: 'en_US.UTF-8',
  template: 'template0',
});
```
Example
```
// Create database with MySQL/MariaDB
await prorm.createDatabase({
  name: 'myapp',
  encoding: 'UTF8',
  collate: 'utf8mb4_unicode_ci',
});
```
- Defined in prorm.ts:7289

dropDatabase

dropDatabase(name: string): Promise<void>
Drop a database if it exists.
Parameters
- name: string
Returns Promise<void>
Example
```
await prorm.dropDatabase('olddb');
```
- Defined in prorm.ts:7312

sync

sync(options?: SyncOptions): Promise<Prorm>
Parameters
- options: SyncOptions = {}
Returns Promise<Prorm>
- Defined in prorm.ts:7320

registerStore

registerStore(
    name: string,
    store: unknown,
    options?: RegisterStoreOptions,
): this
Register an object or key-value store for use by @ExternalField.

Accepts any of the shipped stores (S3, MinIO, R2, GCS, Azure Blob, Redis, ...) directly - the differing method names are normalized internally - or any object implementing ExternalStoreAdapter.
```
const s3 = new S3Store({ region: 'us-east-1' });
await s3.connect();
prorm.registerStore('assets', s3, { defaultBucket: 'avatars' });
```
Parameters
- name: string
- store: unknown
- options: RegisterStoreOptions = {}
Returns this
- Defined in prorm.ts:7454

registerProcedures

registerProcedures(procedureClass: Function): this
Parameters
- procedureClass: Function
Returns this
- Defined in prorm.ts:7459

getMigrator

getMigrator(): any
Get the migration configuration

Returns any
- Defined in prorm.ts:8679

migrate

migrate(options?: { migration?: string }): Promise<any>
Run pending migrations
Parameters
- Optionaloptions: { migration?: string }
Returns Promise<any>
- Defined in prorm.ts:8697

migrateUndo

migrateUndo(options?: { steps?: number; migration?: string }): Promise<any>
Revert migrations
Parameters
- Optionaloptions: { steps?: number; migration?: string }
Returns Promise<any>
- Defined in prorm.ts:8705

migrateStatus

migrateStatus(): Promise<any>
Get migration status

Returns Promise<any>
- Defined in prorm.ts:8713

fn

fn(fnName: string, ...args: (string | Literal | Col | Fn)[]): Fn

Create a SQL function expression

Parameters

fnName: string
The SQL function name (e.g., 'COUNT', 'UPPER', 'YEAR', 'SUM', 'AVG', 'LOWER')
...args: (string | Literal | Col | Fn)[]
The arguments to the function (column names, column references, or other functions)

Returns Fn

A Fn object that can be used in query attributes

Example

// COUNT(id) -> COUNT(id)
prorm.fn('COUNT', 'id')

// UPPER(name) -> UPPER(name)
prorm.fn('UPPER', prorm.col('name'))

// YEAR(createdAt) -> YEAR(createdAt)
prorm.fn('YEAR', 'createdAt')

// COUNT with column reference
prorm.fn('COUNT', prorm.col('id'))

// Nested function: UPPER(LOWER(name))
prorm.fn('UPPER', prorm.fn('LOWER', 'name'))

// Use in findAll
User.findAll({
  attributes: ['role', [prorm.fn('COUNT', prorm.col('id')), 'count']]
})

col

col(tableOrColumn: string, column?: string): Col

Create a column reference for use in SQL functions

Parameters

tableOrColumn: string
Table name (if second param provided) or column name
Optionalcolumn: string
Column name (if first param is table name)

Returns Col

A Col object that can be used as an argument to prorm.fn()

Example

// Reference a column in a function
prorm.fn('COUNT', prorm.col('id'))

// Reference with table name: col('User', 'name') -> "User"."name"
prorm.fn('UPPER', prorm.col('User', 'name'))

// Dot notation: col('table.column') -> "table"."column"
prorm.fn('UPPER', prorm.col('User.name'))

// Use in findAll
User.findAll({
  attributes: ['role', [prorm.fn('COUNT', prorm.col('id')), 'count']]
})

cast

cast(value: string | Literal | Col | Fn, type: string): Cast
Create a type cast expression Used to cast a value to a specific data type in SQL queries
Parameters
- value: string | Literal | Col | Fn
  The value to cast (column reference, literal, or other expression)
- type: string
  The target data type (e.g., 'VARCHAR', 'INTEGER', 'DATE', 'BOOLEAN')
Returns Cast
A Cast object that can be used in queries
Example
```
// Cast a string to integer
prorm.cast(prorm.col('count'), 'INTEGER')

// Cast a value to date
prorm.cast(prorm.col('timestamp'), 'DATETIME')

// Cast in where clause
User.findAll({
  where: prorm.cast(prorm.col('active'), 'BOOLEAN')
})

// Use in attributes for type conversion
User.findAll({
  attributes: [[prorm.cast(prorm.col('price'), 'VARCHAR'), 'priceStr']]
})
```
- Defined in prorm.ts:8822

where

where(col: Literal | Col | Fn, value: unknown): WhereObject

Create a where condition for complex queries Allows creating custom WHERE clauses with operators

Parameters

col: Literal | Col | Fn
value: unknown

Returns WhereObject

A WhereObject for use in find options

Example

// Simple equality with column reference
prorm.where(prorm.col('name'), 'John')

// With a comparator operator
prorm.where(prorm.col('age'), { $gt: 18 })

// Complex condition with literal
prorm.where(prorm.literal('LOWER(name)'), 'john')

// Using with fn
prorm.where(prorm.fn('YEAR', prorm.col('createdAt')), 2024)

and

and(...conditions: unknown[]): AndOrObject

Create an AND condition for combining multiple where conditions

Parameters

...conditions: unknown[]
The conditions to combine with AND

Returns AndOrObject

An AndOrObject with AND operator

Example

// Combine multiple conditions
prorm.and(
  { name: 'John' },
  { age: { $gte: 18 } }
)

// Use in where clause
User.findAll({
  where: prorm.and(
    { status: 'active' },
    { role: 'admin' }
  )
})

// Nested with or
prorm.and(
  { active: true },
  prorm.or({ role: 'admin' }, { role: 'moderator' })
)

or

or(...conditions: unknown[]): AndOrObject

Create an OR condition for combining multiple where conditions

Parameters

...conditions: unknown[]
The conditions to combine with OR

Returns AndOrObject

An AndOrObject with OR operator

Example

// Combine multiple conditions
prorm.or(
  { name: 'John' },
  { name: 'Jane' }
)

// Use in where clause
User.findAll({
  where: prorm.or(
    { status: 'active' },
    { role: 'admin' }
  )
})

// Complex nested condition
prorm.or(
  prorm.and({ status: 'active' }, { role: 'admin' }),
  { id: 1 }
)

json

json(path: string, value?: unknown): JsonObject
Create a JSON path query for querying JSON columns Used to query specific paths in JSON columns (PostgreSQL, MySQL JSON)
Parameters
- path: string
  The JSON path to query (dot notation or array notation)
- Optionalvalue: unknown
  Optional value to compare against
Returns JsonObject
A JsonObject for use in where clauses
Example
```
// Query JSON column path
prorm.json('profile.name')

// Query nested JSON path
prorm.json('settings.theme.color')

// Query with value comparison
prorm.json('profile.age', 25)

// Use in where clause
User.findAll({
  where: prorm.json('profile.isActive', true)
})

// Query array element
prorm.json('tags[0]', 'important')
```
- Defined in prorm.ts:8965

`Static`where

where(col: Literal | Col | Fn, value: unknown): WhereObject
Static version of the where method - creates a WHERE condition Can be used without instantiating Prorm
Parameters
- col: Literal | Col | Fn
  The column reference (Col, Fn, or Literal)
- value: unknown
  The value or condition to compare against
Returns WhereObject
A WhereObject for use in find options
- Defined in prorm.ts:8983

`Static`and

and(...conditions: unknown[]): AndOrObject
Static version of the and method - combines conditions with AND Can be used without instantiating Prorm
Parameters
- ...conditions: unknown[]
  The conditions to combine with AND
Returns AndOrObject
An AndOrObject with AND operator
- Defined in prorm.ts:8997

`Static`or

or(...conditions: unknown[]): AndOrObject
Static version of the or method - combines conditions with OR Can be used without instantiating Prorm
Parameters
- ...conditions: unknown[]
  The conditions to combine with OR
Returns AndOrObject
An AndOrObject with OR operator
- Defined in prorm.ts:9010

`Static`json

json(path: string, value?: unknown): JsonObject
Static version of the json method - creates a JSON path query Can be used without instantiating Prorm
Parameters
- path: string
  The JSON path to query
- Optionalvalue: unknown
  Optional value to compare against
Returns JsonObject
A JsonObject for use in where clauses
- Defined in prorm.ts:9024

`Static`validate

validate(
values: Record<string, unknown>,
options?: { model?: ModelStatic<any> },
): Promise<ValidationError | null>
Static version of the validate method - validates a model's values Can be used without instantiating Prorm
Parameters
- values: Record<string, unknown>
  The values to validate
- Optionaloptions: { model?: ModelStatic<any> }
  Validation options
Returns Promise<ValidationError | null>
A promise that resolves with validation errors
- Defined in prorm.ts:9039

Class Prorm

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns Prorm

Example

Example

Example

Example

Properties

connectionManager

associations

ReadonlyexternalStores

External Field

pool

Example

Accessors

models

Returns Record<string, ModelStatic<AnyModel>>

modelManager

Returns { models: Record<string, ModelStatic<AnyModel>>; all: ModelStatic<any>[]; getModel(name: string): ModelStatic<any> | undefined; addModel(name: string, model: ModelStatic<any>): void; removeModel(name: string): boolean;}

isConnected

Returns boolean

allModels

Returns Record<string, ModelStatic<AnyModel>>

fdw

Returns ForeignDataManager

Example

users

Returns UserManager

Example

UUIDV4

Returns Literal

Example

Methods

literal

Parameters

Returns Literal

Example

Example

Example

Example

getPool

Returns DatabaseConnectionPool | null

getPoolStats

Returns { size: number; available: number; inUse: number; pending: number } | null

getLogger

Returns Logger

setLoggingLevel

Parameters

Returns void

connect

Returns Promise<void>

close

Returns Promise<void>

addHook

Parameters

Returns this

Example

Example

authenticate

Returns Promise<void>

Throws

Example

getDialect

Returns string

getDialectInstance

Returns Dialect | null

getQueryInterface

Returns any

createPartitionedTable

Parameters

Returns Promise<void>

createPartition

`Readonly`externalStores

Returns {
models: Record<string, ModelStatic<AnyModel>>;
all: ModelStatic<any>[];
getModel(name: string): ModelStatic<any> | undefined;
addModel(name: string, model: ModelStatic<any>): void;
removeModel(name: string): boolean;
}

`Optional`definition?: ViewDefinition

`Optional`query?: string

`Optional`schema?: string

`Optional`ifNotExists?: boolean