ts-prorm-orm 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,1111 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Comprehensive Feature Reference
+
+This section provides a complete reference of all ORM features organized by category.
+
+---
+
+## Database Dialects
+
+| Dialect | Status | Notes |
+|---------|--------|-------|
+| SQLite | ✅ Stable | In-memory, file-based, attach/detach |
+| PostgreSQL | ✅ Stable | Full feature support |
+| MySQL | ✅ Stable | InnoDB, MyISAM engines |
+| MariaDB | ✅ Stable | MySQL compatible |
+| MSSQL/SQL Server | ⚠️ Experimental | RLS, partitions, procedures, triggers, user management |
+| Oracle | ⚠️ Experimental | Sequences, partitions, procedures, triggers, materialized views, user management |
+
+### Dialect-Specific Features
+
+**SQLite:**
+- `attach(database, alias)` - Attach multiple databases
+- `detach(alias)` - Detach database
+- `backup(targetDb)` - Online backup
+- `optimize()` - VACUUM and ANALYZE
+- `pragma(name, value)` - Database pragmas
+- Full-text search (FTS5)
+- Window functions
+- CTEs (Common Table Expressions)
+- Recursive queries
+- Savepoints
+
+**PostgreSQL:**
+- Foreign Data Wrappers (FDW)
+- Database extensions
+- User/Role management
+- Row-level security (RLS)
+- Partitioned tables
+- Materialized views
+- Window functions
+- Array types
+- JSON/JSONB
+- HSTORE key-value
+- Range types
+
+**MySQL/MariaDB:**
+- Storage engine selection
+- Charset/Collation
+- Partitioning
+- Full-text search
+- Spatial/GIS types
+- Sequences (via AUTO_INCREMENT table pattern)
+- Partial indexes
+- Stored procedures and triggers
+
+**Oracle:**
+- Schema support
+- Sequences with CYCLE and CACHE options
+- Stored procedures and functions
+- Triggers (BEFORE, AFTER, INSTEAD OF)
+- Materialized views with FAST/COMPLETE refresh
+- User and role management
+- Partitioned tables (RANGE, LIST, HASH)
+- Row-level security (VPD policies)
+
+**MSSQL/SQL Server:**
+- Schema support
+- Sequences
+- Stored procedures and functions
+- Triggers (INSTEAD OF, AFTER)
+- User and role management
+- Partitioned tables
+- Row-level security (Security Policies)
+
+---
+
+## Data Types
+
+### String Types
+- `STRING(length, binary)` - VARCHAR or TEXT
+- `VARCHAR(length, binary)` - Variable-length
+- `CHAR(length)` - Fixed-length
+- `TEXT('tiny'|'medium'|'long')` - Unlimited text
+
+### Number Types
+- `INTEGER({length, unsigned, zerofill})` - 32-bit integer
+- `BIGINT({length, unsigned, zerofill})` - 64-bit integer
+- `FLOAT(precision)` - Floating-point
+- `DOUBLE(precision)` - Double precision
+- `DECIMAL(precision, scale, unsigned)` - Fixed-point
+- `REAL` - Single precision
+
+### Boolean & Date
+- `BOOLEAN` - True/false
+- `DATE(precision, timezone)` - DateTime with timezone
+- `DATEONLY` - Date only (no time)
+- `TIME(precision, timezone)` - Time only
+- `NOW` - Current timestamp
+
+### UUID & JSON
+- `UUID` - Universal unique identifier
+- `UUIDV4` - Auto-generate UUID v4
+- `JSON(useNative)` - JSON object
+- `JSONB(useNative)` - Binary JSON (PostgreSQL)
+
+### Binary Types
+- `BLOB('tiny'|'medium'|'long')` - Binary data
+- `BINARY(length)` - Fixed binary
+- `VARBINARY(length)` - Variable binary
+
+### Enum & Array
+- `ENUM(...values)` - Enumeration
+- `ARRAY(type)` - PostgreSQL array
+
+### Spatial & Network
+- `GEOMETRY(type, srid)` - Spatial geometry
+- `GEOGRAPHY(type, srid)` - Geographic coordinates
+- `HSTORE(useNative)` - Key-value store (PostgreSQL)
+- `RANGE(subtype)` - Range types (PostgreSQL)
+- `INET` - IPv4/IPv6 address
+- `CIDR` - Network address
+- `MACADDR` - MAC address
+
+### Special Types
+- `INTERVAL` - Time interval
+- `DECIMAL(precision, scale)` - Numeric with precision
+- `NUMBER` - Generic number
+
+---
+
+## Query Operators (Op)
+
+### Comparison Operators
+- `Op.eq` / `Op.ne` - Equal / Not equal
+- `Op.gt` / `Op.gte` - Greater than / Greater or equal
+- `Op.lt` / `Op.lte` - Less than / Less or equal
+
+### Set Membership
+- `Op.in` - Value in array
+- `Op.notIn` - Value not in array
+
+### Range Operators
+- `Op.between` - Between range (inclusive)
+- `Op.notBetween` - Not between range
+
+### Pattern Matching
+- `Op.like` / `Op.notLike` - LIKE pattern match
+- `Op.iLike` / `Op.notILike` - Case-insensitive LIKE
+- `Op.regexp` / `Op.notRegexp` - Regular expression
+- `Op.iRegexp` / `Op.notIRegexp` - Case-insensitive regex
+- `Op.startsWith` / `Op.notStartsWith` - Prefix match
+- `Op.endsWith` / `Op.notEndsWith` - Suffix match
+- `Op.substring` / `Op.notSubstring` - Substring match
+- `Op.match` - Full-text search (MySQL/PostgreSQL)
+
+### Null Checks
+- `Op.isNull` - IS NULL
+- `Op.isNotNull` - IS NOT NULL
+
+### Logical Operators
+- `Op.and` - AND conjunction
+- `Op.or` - OR disjunction
+- `Op.not` - NOT negation
+
+### JSON/Array Operators
+- `Op.contains` - Contains (JSON/array)
+- `Op.overlap` - Overlap (array)
+- `Op.all` - ALL array elements
+- `Op.any` - ANY array element
+- `Op.adjacent` - Adjacent ranges
+
+### Existence Operators
+- `Op.exists` / `Op.notExists` - EXISTS subquery
+
+### Helper Functions
+- `where()` - Create where clause
+- `and()` - AND helper
+- `or()` - OR helper
+- `not()` - NOT helper
+- `like()`, `iLike()` - Like helpers
+- `between()`, `notBetween()` - Range helpers
+- `inOp()`, `notIn()` - IN helpers
+- `isNull()`, `isNotNull()` - NULL helpers
+- `asc()`, `desc()` - Order helpers
+
+---
+
+## CRUD Operations
+
+### Create
+- `Model.create(values, options)` - Insert record
+- `Model.bulkCreate(records, options)` - Batch insert
+- `Model.upsert(values, options)` - Insert or update
+- `instance.save(options)` - Save instance
+
+### Read
+- `Model.findAll(options)` - Find all matching
+- `Model.findOne(options)` - Find first match
+- `Model.findByPk(pk, options)` - Find by primary key
+- `Model.findOrCreate(options)` - Find or create
+- `Model.findAndCountAll(options)` - Find with count
+
+### Update
+- `Model.update(values, options)` - Update matching
+- `instance.update(values, options)` - Update instance
+- `instance.save(options)` - Persist changes
+
+### Delete
+- `Model.destroy(options)` - Delete matching
+- `instance.destroy(options)` - Delete instance
+- `Model.truncate(options)` - Truncate table
+
+### Aggregates
+- `Model.count(options)` - COUNT(*)
+- `Model.sum(field, options)` - SUM(field)
+- `Model.min(field, options)` - MIN(field)
+- `Model.max(field, options)` - MAX(field)
+- `Model.avg(field, options)` - AVG(field)
+- `Model.increment(fields, options)` - Atomic increment
+- `Model.decrement(fields, options)` - Atomic decrement
+
+### Instance Methods
+- `instance.get(key)` - Get field value
+- `instance.set(key, value)` - Set field value
+- `instance.changed()` - Get changed fields
+- `instance.previous(key)` - Get previous value
+- `instance.reload(options)` - Reload from DB
+
+### Raw Queries
+- `prorm.query(sql, options)` - Raw SQL
+- `Model.rawQuery(sql, options)` - Raw with model
+
+---
+
+## Query Options
+
+### Where Clause
+```typescript
+{
+  where: {
+    field: value,
+    field: { [Op.operator]: value },
+    [Op.and]: [{ field: value }, { field: value }],
+    [Op.or]: [{ field: value }, { field: value }],
+    [Op.not]: { field: value }
+  }
+}
+```
+
+### Include (Joins)
+```typescript
+{
+  include: [
+    { model: OtherModel, as: 'alias' },
+    { model: OtherModel, where: { ... }, required: true },
+    { model: ThroughModel, through: { where: { ... } } }
+  ]
+}
+```
+
+### Attributes
+```typescript
+{
+  attributes: ['id', 'name'],
+  attributes: { include: ['id'], exclude: ['password'] }
+}
+```
+
+### Ordering & Grouping
+```typescript
+{
+  order: [['name', 'ASC'], ['createdAt', 'DESC']],
+  group: 'category',
+  having: { count: { [Op.gt]: 10 } }
+}
+```
+
+### Pagination
+```typescript
+{
+  limit: 10,
+  offset: 20
+}
+```
+
+### Locking
+```typescript
+{
+  lock: Transaction.LOCK.UPDATE,
+  lock: Transaction.LOCK.SHARE
+}
+```
+
+---
+
+## Associations
+
+### Association Types
+- `Model.hasOne(Target, options)` - One-to-One
+- `Model.hasMany(Target, options)` - One-to-Many
+- `Model.belongsTo(Target, options)` - Many-to-One
+- `Model.belongsToMany(Target, { through })` - Many-to-Many
+
+### Association Options
+- `as` - Alias
+- `foreignKey` - Foreign key name
+- `otherKey` - Target key (belongsToMany)
+- `onDelete` - CASCADE/SET NULL/RESTRICT
+- `onUpdate` - CASCADE/SET NULL/RESTRICT
+- `through` - Junction model
+- `constraints` - Enable/disable FK constraints
+
+### Association Methods (Auto-generated)
+- `instance.getAlias()` - Get associated
+- `instance.setAlias(value)` - Set associated
+- `instance.createAlias()` - Create associated
+- `instance.addAlias()` - Add to association
+- `instance.removeAlias()` - Remove from association
+- `instance.hasAlias()` - Check membership
+- `instance.countAlias()` - Count associated
+
+### Special Associations
+- Self-referencing (tree structures)
+- Composite primary keys
+- Custom join table names
+- Non-unique foreign keys
+- Polymorphic associations
+
+### Eager Loading
+- `include: [{ model: X }]` - Load with
+- `{ all: true }` - Load all associations
+- `{ nested: true }` - Recursive load
+- `{ where: {} }` - Filter included
+- `{ required: true }` - INNER JOIN
+
+---
+
+## Hooks / Lifecycle Events
+
+### Model Hooks
+- `beforeValidate` / `afterValidate`
+- `beforeCreate` / `afterCreate`
+- `beforeUpdate` / `afterUpdate`
+- `beforeSave` / `afterSave`
+- `beforeDestroy` / `afterDestroy`
+- `beforeUpsert` / `afterUpsert`
+- `beforeBulkCreate` / `afterBulkCreate`
+- `beforeBulkUpdate` / `afterBulkUpdate`
+- `beforeBulkDestroy` / `afterBulkDestroy`
+- `beforeFind` / `afterFind`
+- `beforeCount` / `afterCount`
+
+### Instance Hooks
+- `beforeDefine` / `afterDefine`
+- `beforeSync` / `afterSync`
+- `beforeConnect` / `afterConnect`
+- `beforeDisconnect` / `afterDisconnect`
+
+### Hook Options
+- `hooks: { beforeCreate: fn }` - Define in model
+- `model.addHook('hook', fn)` - Add after definition
+- `{ hooks: false }` - Disable hooks
+- `{ validate: false }` - Skip validation
+
+---
+
+## Validators
+
+### Built-in Validators
+- `notNull` - Not null
+- `notEmpty` - Not empty string
+- `isEmail` - Valid email
+- `isUrl` - Valid URL
+- `isIP` - IP address
+- `isIPv4` / `isIPv6` - Specific IP
+- `isAlpha` - Letters only
+- `isAlphanumeric` - Letters and numbers
+- `isNumeric` - Numbers only
+- `isInt` / `isFloat` - Number types
+- `isDecimal` - Decimal numbers
+- `isLowercase` / `isUppercase` - Case
+- `isDate` - Valid date
+- `isAfter(date)` - After date
+- `isBefore(date)` - Before date
+- `isIn(array)` - In array
+- `notIn(array)` - Not in array
+- `len(min, max)` - Length check
+- `min` / `max` - Numeric bounds
+- `matches(regex)` - Regex match
+- `contains(str)` - Contains substring
+- `notContains(str)` - Not contains
+- `isCreditCard` - Credit card number
+- `isFQDN` - Fully qualified domain
+- `isUUID` - UUID format
+- `isDateString` - Date string
+
+### Custom Validators
+```typescript
+{
+  validate: {
+    myValidator(value) {
+      if (condition) throw new Error('Invalid');
+    }
+  }
+}
+```
+
+### Cross-field Validation
+```typescript
+{
+  validate: {
+    passwordMatch() {
+      if (this.password !== this.confirmPassword) {
+        throw new Error('Passwords do not match');
+      }
+    }
+  }
+}
+```
+
+---
+
+## Scopes
+
+### Default Scope
+```typescript
+{
+  defaultScope: {
+    where: { active: true },
+    order: ['createdAt', 'DESC']
+  }
+}
+```
+
+### Named Scopes
+```typescript
+{
+  scopes: {
+    active: { where: { active: true } },
+    popular: { where: { views: { [Op.gt]: 100 } } },
+    recent: (days) => ({
+      where: {
+        createdAt: { [Op.gte]: daysAgo(days) }
+      }
+    })
+  }
+}
+```
+
+### Scope Methods
+- `Model.scope('name')` - Apply scope
+- `Model.scope(['a', 'b'])` - Combine scopes
+- `Model.unscoped()` - Remove default scope
+- `Model.addScope('name', options)` - Add scope dynamically
+
+---
+
+## Transactions
+
+### Transaction Types
+- `prorm.transaction(fn)` - Managed (auto commit/rollback)
+- `prorm.transaction()` - Manual transaction
+
+### Transaction Options
+```typescript
+{
+  isolationLevel: Transaction.ISOLATION_LEVELS.READ_COMMITTED,
+  type: Transaction.TYPES.DEFERRED
+}
+```
+
+### Isolation Levels
+- `READ_UNCOMMITTED`
+- `READ_COMMITTED`
+- `REPEATABLE_READ`
+- `SERIALIZABLE`
+
+### Transaction Types (SQLite)
+- `DEFERRED`
+- `IMMEDIATE`
+- `EXCLUSIVE`
+
+### Locking
+- `LOCK.UPDATE` - Pessimistic write lock
+- `LOCK.SHARE` - Pessimistic read lock
+
+### Savepoints
+- `t.savepoint(name)` - Create savepoint
+- `t.rollbackTo(name)` - Rollback to savepoint
+- `t.releaseSavepoint(name)` - Release savepoint
+
+---
+
+## Indexes & Constraints
+
+### Index Types
+- `primaryKey` - Primary key (auto)
+- `unique` - Unique index
+- `index` - Regular index
+- `fulltext` - Full-text search
+- `spatial` - Spatial index
+
+### Index Options
+```typescript
+{
+  indexes: [
+    { fields: ['email'], unique: true },
+    { fields: [{ attribute: 'name', length: 10 }] },
+    { fields: ['status'], where: { deletedAt: null } }, // Partial
+    { fields: [{ expression: 'LOWER(name)' }] }, // Functional
+    { type: 'BTREE' | 'HASH' | 'GIN' | 'GiST' | 'BRIN' }
+  ]
+}
+```
+
+### Constraints
+- `primaryKey` - Primary key
+- `unique` - Unique constraint
+- `foreignKey` - Foreign key
+- `check` - CHECK constraint
+- `exclusion` - Exclusion (PostgreSQL)
+
+### Foreign Key Actions
+- `onDelete`: CASCADE / SET NULL / RESTRICT / NO ACTION
+- `onUpdate`: CASCADE / SET NULL / RESTRICT / NO ACTION
+
+---
+
+## Migrations
+
+### Migration Class
+```typescript
+class Migration20240101 extends Migration {
+  async up(queryInterface, Prorm) {
+    await queryInterface.createTable('users', { ... });
+  }
+
+  async down(queryInterface, Prorm) {
+    await queryInterface.dropTable('users');
+  }
+}
+```
+
+### Query Interface Methods
+- `createTable` / `dropTable`
+- `addColumn` / `removeColumn` / `changeColumn`
+- `renameColumn` / `renameTable`
+- `addIndex` / `removeIndex`
+- `addConstraint` / `removeConstraint`
+- `createView` / `dropView`
+- `createSchema` / `dropSchema`
+- `bulkInsert` / `bulkDelete` / `bulkUpdate`
+
+### CLI Commands
+- `orm migration:create` - Generate migration
+- `orm db:migrate` - Run migrations
+- `orm db:migrate:undo` - Undo last
+- `orm db:migrate:undo:all` - Undo all
+- `orm db:migrate:status` - Show status
+- `orm db:seed` - Run seeders
+- `orm db:seed:undo` - Undo seeders
+
+---
+
+## Soft Deletes (Paranoid)
+
+### Enable
+```typescript
+{
+  paranoid: true, // Adds deletedAt column
+  deletedAt: 'deletedAt' // Custom column name
+}
+```
+
+### Operations
+- `destroy()` - Sets deletedAt (soft delete)
+- `destroy({ force: true })` - Hard delete
+- `restore()` - Restore soft-deleted
+- `findAll({ paranoid: false })` - Include deleted
+
+---
+
+## Virtual Fields
+
+### Define
+```typescript
+{
+  fullName: {
+    type: DataTypes.VIRTUAL,
+    get() { return `${this.firstName} ${this.lastName}`; }
+  }
+}
+```
+
+### With Setter
+```typescript
+{
+  name: {
+    type: DataTypes.VIRTUAL,
+    get() { return this.getDataValue('name'); },
+    set(value) { this.setDataValue('name', value.toUpperCase()); }
+  }
+}
+```
+
+---
+
+## Connection Pool
+
+### Configuration
+```typescript
+{
+  pool: {
+    min: 2,
+    max: 10,
+    idle: 10000,
+    acquire: 30000,
+    evict: 1000
+  }
+}
+```
+
+### Pool Events
+- `acquire` / `release`
+- `create` / `destroy`
+- `error` / `enqueue` / `dequeue`
+- `timeout` / `health-check`
+
+### Pool Metrics
+```typescript
+pool.metrics.size        // Total pool size
+pool.metrics.available  // Available connections
+pool.metrics.inUse       // In-use connections
+```
+
+---
+
+## Query Optimization
+
+### Slow Query Logger
+```typescript
+{
+  slowQueryThreshold: 1000,
+  alertThreshold: 5000,
+  onSlowQuery: (sql, timing) => { ... }
+}
+```
+
+### Explain Plans
+```typescript
+{
+  explain: {
+    format: 'JSON' | 'TEXT' | 'XML' | 'YAML'
+  }
+}
+```
+
+### Prepared Statements
+```typescript
+{
+  preparedStatements: true,
+  cachePreparedStatements: 100 // LRU cache size
+}
+```
+
+### Query Hints
+- MySQL: `USE INDEX`, `FORCE INDEX`
+- PostgreSQL: `SET`, `hint`
+
+### Batch Optimizer
+```typescript
+{
+  batchSize: 1000,
+  useTransaction: true,
+  onProgress: (completed, total) => { ... }
+}
+```
+
+---
+
+## Decorators
+
+### Security
+- `@Secure` - Password hashing
+- `@SecureField` - Field-level encryption
+- `createBcryptAdapter()` - Bcrypt hashing
+- `createArgon2Adapter()` - Argon2 hashing
+
+### Database Objects
+- `@Procedure` - Stored procedure
+- `@SqlFunction` - SQL function
+- `@View` - Database view
+
+### Permissions
+- `@CanView` / `@CannotView`
+- `@CanWrite` / `@CannotWrite`
+- `@Permission` - Field-level permissions
+- `filterByPermissions()` - Filter output
+- `filterWriteByPermissions()` - Filter input
+
+### Field Mapping
+- `@Column` - Column name mapping
+- `@Table` - Table configuration
+- `@Index` - Index definition
+- `@ForeignKey` - Foreign key
+- `@Comment` - Documentation
+- `@Default` - Default value
+- `@Generated` - Auto-generated
+- `@Check` - Check constraint
+
+### Type Decorators
+- `@HStore` - PostgreSQL HSTORE
+- `@JsonColumn` / `@Jsonb` - JSON column
+- `@Range` - PostgreSQL range
+- `@SetColumn` - Set column type
+- `@Spatial` - Spatial type
+- `@Uuid` - UUID type
+
+---
+
+## CLI Commands
+
+### Model Generation
+```bash
+orm model:generate --name User --attributes name:string,email:string
+```
+
+### Migration
+```bash
+orm migration:create --name add_field
+orm db:migrate
+orm db:migrate:undo
+```
+
+### Database
+```bash
+orm db:seed
+orm db:seed:undo
+orm db:migrate:status
+```
+
+### Diagram Generation
+```bash
+orm diagram:model --file User.json --out User.svg
+orm diagram:er --file schema.json --out schema.svg
+```
+
+---
+
+## SQLite Advanced Features
+
+### Views
+- `createView(name, definition)`
+- `dropView(name)`
+- `listViews()`
+- `getViewDefinition(name)`
+
+### Triggers
+- `createTrigger(name, table, event, action)`
+- `createAfterInsertTrigger(name, table, action)`
+- `createAfterUpdateTrigger(name, table, action)`
+- `createAfterDeleteTrigger(name, table, action)`
+- `createBeforeInsertTrigger(name, table, action)`
+- `createInsteadOfTrigger(name, table, action)`
+- `dropTrigger(name)`
+- `listTriggers()`
+
+### Full-Text Search (FTS5)
+- `createFTS5Table(name, columns)`
+- `createFTS5FromTable(source, fts)`
+- `fullTextSearch(table, query)`
+- `fts5Search(ftsTable, query)`
+- `rebuildFTS5(table)`
+- `optimizeFTS5(table)`
+
+### JSON Functions
+- `jsonExtract(column, path)`
+- `jsonSet(column, path, value)`
+- `jsonArrayAppend(column, path, value)`
+- `jsonRemove(column, path)`
+- `jsonArrayLength(column, path)`
+- `jsonContains(column, value)`
+- `jsonEach(column, path)` - As table
+- `jsonTree(column, path)` - As tree
+
+### Window Functions
+- `rowNumber()`
+- `rank()`
+- `denseRank()`
+- `ntile(n)`
+- `lag(column, offset, default)`
+- `lead(column, offset, default)`
+- `firstValue(column)`
+- `lastValue(column)`
+- `nthValue(column, n)`
+
+### CTEs (Common Table Expressions)
+- `buildCTE(name, columns, query, recursive)`
+- `executeRecursiveCTE(cte, baseCase, recursiveCase)`
+
+### Database Management
+- `vacuum(options)` - Optimize database
+- `analyze(target)` - Update statistics
+- `getTableStats(table)`
+- `getIndexStats(index)`
+- `reindex(target)`
+- `pragma(name, value)`
+
+### Savepoints
+- `savepoint(name)`
+- `releaseSavepoint(name)`
+- `rollbackToSavepoint(name)`
+- `withSavepoint(name, fn)`
+
+### Extensions
+- `loadExtension(path)`
+- `setExtensionLoading(enabled)`
+- `getLoadedExtensions()`
+
+---
+
+## PostgreSQL Features
+
+### Foreign Data Wrappers
+- `createServer(name, options)`
+- `createUserMapping(server, user, options)`
+- `createForeignTable(name, server, columns)`
+- `importForeignSchema(remoteServer, remoteSchema)`
+- `listServers()`
+- `dropForeignTable(name)`
+
+### Extensions
+- `createExtension(name)`
+- `dropExtension(name)`
+- `listExtensions()`
+
+### User Management
+- `createUser(name, options)`
+- `createRole(name, options)`
+- `grantRole(user, role)`
+- `grant(privilege, object, to)`
+- `revoke(privilege, object, from)`
+- `listUsers()`
+- `listPrivileges(user)`
+
+### Row-Level Security
+- Enable on table with RLS policy
+- `createPolicy(name, table, using, with_check)`
+- `dropPolicy(name, table)`
+
+### Materialized Views
+- `createMaterializedView(name, query)`
+- `refreshMaterializedView(name)`
+- `dropMaterializedView(name)`
+
+---
+
+## Error Classes
+
+### Core Errors
+- `PrormError` - Base error
+- `ConnectionError` - Connection failures
+- `DatabaseError` - SQL errors
+- `ValidationError` - Validation failures
+
+### Constraint Errors
+- `UniqueConstraintError` - Duplicate key
+- `ForeignKeyConstraintError` - FK violation
+- `ExclusionConstraintError` - Exclusion violation
+
+### Other Errors
+- `TimeoutError` - Connection/query timeout
+- `ResourceLockedError` - Deadlock/lock conflict
+- `BulkRecordError` - Bulk operation error
+- `AssociationError` - Association misuse
+- `EmptyResultError` - No results found
+
+### Error Helpers
+- `isPrormError(error)`
+- `isValidationError(error)`
+- `isConnectionError(error)`
+- `isConstraintError(error)`
+- `isEmptyResultError(error)`
+- `wrapError(error, message)`
+- `formatError(error)`
+
+---
+
+## Utilities
+
+### Case Conversion
+- `camelToSnake(str)`
+- `snakeToCamel(str)`
+- `camelToKebab(str)`
+- `kebabToCamel(str)`
+- `camelize(str)`
+- `snakeCase(str)`
+- `upperFirst(str)`
+- `lowerFirst(str)`
+
+### Inflection
+- `pluralize(word)`
+- `singularize(word)`
+
+### Object Helpers
+- `cloneDeep(obj)`
+- `merge(target, source)`
+- `pick(obj, keys)`
+- `omit(obj, keys)`
+- `isEmpty(obj)`
+- `coalesce(...values)`
+
+### UUID
+- `generateUUID()`
+- `generateShortUUID()`
+- `isValidUUID(str)`
+
+### SQL Formatting
+- `formatValues(values, dialect)`
+- `formatValue(value, dialect)`
+- `escapeString(str, dialect)`
+- `escapeId(identifier, dialect)`
+- `formatWhere(where, dialect)`
+- `escapeLike(pattern, dialect)`
+
+### String Utilities
+- `upperCase(str)`
+- `lowerCase(str)`
+- `capitalize(str)`
+- `capitalizeWords(str)`
+- `trim(str)`
+- `padStart(str, length, char)`
+- `padEnd(str, length, char)`
+- `truncate(str, length)`
+
+### Date Utilities
+- `now()`
+- `today()`
+- `utcNow()`
+- `dateToString(date)`
+- `stringToDate(str)`
+
+### Validation
+- `isEmail(str)`
+- `isURL(str)`
+- `isUUID(str)`
+- `isIP(str)`
+- `isMobilePhone(str)`
+
+---
+
+## Logging
+
+### Log Levels
+- `LogLevel.DEBUG`
+- `LogLevel.INFO`
+- `LogLevel.WARN`
+- `LogLevel.ERROR`
+- `LogLevel.SILENT`
+
+### Logger Methods
+- `logger.debug(msg, meta)`
+- `logger.info(msg, meta)`
+- `logger.warn(msg, meta)`
+- `logger.error(msg, meta)`
+
+### SQL Logging
+```typescript
+{
+  logging: console.log        // Console logging
+  logging: (sql) => { ... }   // Custom function
+  logging: false               // Disable
+}
+```
+
+### Custom Logger
+- `createLogger(options)`
+- `createSilentLogger()`
+- `getDefaultLogger()`
+- `setDefaultLogger(logger)`
+
+---
+
+## Recent Additions
+
+### Added (v1.0.0+)
+
+#### Database Features Implemented Across All Dialects
+- **Sequences**: Full implementation for PostgreSQL, MySQL, MariaDB, SQLite, Oracle, MSSQL
+  - `createSequence(name, options)` - Create sequence with start, increment, min/max, cycle options
+  - `dropSequence(name)` - Drop sequence
+  - `nextSequenceValue(name)` - Get next value
+  - `currSequenceValue(name)` - Get current value
+  - `listSequences()` - List all sequences
+
+- **Table Partitions**: Full implementation for all 6 dialects
+  - `createPartition(table, type, ranges)` - Create table partition (RANGE, LIST, HASH)
+  - `dropPartition(table, partition)` - Drop partition
+  - `addPartition(table, partition)` - Add new partition
+  - `listPartitions(table)` - List partitions
+
+- **Partial Indexes**: Implementation for MySQL, MariaDB, PostgreSQL, Oracle, MSSQL
+  - `createPartialIndex(table, indexName, fields, where, options)` - Partial/conditional index
+
+- **Stored Procedures**: Full implementation with parameter support
+  - `createProcedure(name, params, returnType, body)` - Create stored procedure
+  - `dropProcedure(name)` - Drop procedure
+  - `listProcedures(schema)` - List procedures
+
+- **Triggers**: Full implementation with FOR EACH ROW and WHEN clause support
+  - `createTrigger(options)` - Create trigger with timing, events, body, forEachRow, when
+  - `dropTrigger(name, table)` - Drop trigger
+  - `listTriggers(table)` - List triggers
+
+- **Materialized Views**: Implementation for PostgreSQL and Oracle
+  - `createMaterializedView(name, query, options)` - Create materialized view
+  - `refreshMaterializedView(name, method)` - Refresh with COMPLETE or FAST
+  - `dropMaterializedView(name)` - Drop view
+
+- **User Management**: Implementation for Oracle, MSSQL, PostgreSQL
+  - `createUser(name, options)` - Create database user with password, profile, quotas
+  - `dropUser(name)` - Drop user
+  - `createRole(name, options)` - Create role
+  - `grant(privilege, object, to)` - Grant privileges
+  - `revoke(privilege, object, from)` - Revoke privileges
+  - `listUsers()` / `listRoles()` - List users and roles
+
+- **Row-Level Security (RLS)**: Implementation for PostgreSQL, Oracle, MSSQL
+  - PostgreSQL: `createPolicy(name, table, using, with_check)` with RLS enable
+  - Oracle: VPD policies using `createPolicy()`
+  - MSSQL: Security policies with `createSecurityPolicy()`
+
+#### Association Enhancements
+- **Polymorphic Associations**: `polymorphicHasMany()`, `polymorphicBelongsTo()`
+- **Self-referential Associations**: `hasManyChildren()`, `belongsToParent()`
+
+#### Dialect Status Updates
+- Oracle dialect support (experimental) - Now with sequences, stored procedures, triggers, materialized views
+- MSSQL/SQL Server dialect support (experimental) - Now with RLS, user management, partitions
+- New column type decorators: `@HStore`, `@JsonColumn`, `@Jsonb`, `@Range`, `@SetColumn`, `@Spatial`, `@Uuid`
+- Organized examples: `examples/advanced/`, `examples/basic/`, `examples/concepts/`, `examples/diagrams/`, `examples/real-world/`
+- New documentation: Events, MariaDB, MySQL, PostgreSQL guides
+- GitLab CI pipeline with matrix builds (Node 18/20/22), test, lint, coverage stages
+- GitLab Pages deployment for documentation
+- GitLab Package Registry publishing on tags
+- Pre-commit hooks with husky and lint-staged
+- SQLite advanced features: attach database, detach, backup, optimize
+- Stored procedures and functions support
+- Triggers support for automatic actions on insert/update/delete
+- Materialized views support
+- Full-text search with indexable columns
+- Check constraints for custom validation rules
+- Collation and charset configuration per column
+- Comment annotations for tables and columns
+- Database storage engine configuration (MySQL/MariaDB)
+- Timezone-aware timestamps
+- Generated/computed columns
+- Row-level security (PostgreSQL)
+- Composite foreign keys
+- Composite unique constraints
+- Partial indexes
+- Functional indexes
+- Partitioned tables (PostgreSQL, MySQL)
+- Window functions support
+- CTEs (Common Table Expressions) support
+- Recursive queries
+- Bulk operations with upsert
+- Named constraints
+- Foreign table wrappers (PostgreSQL)
+- User and role management (PostgreSQL, MySQL)
+- Privilege grants and revocations
+- Database extensions management
+- Seeder for test data population
+- Event system for custom events
+- Audit logging for changes tracking
+
+### Changed
+- Improved TypeScript generic inference on `findAll` return types
+- Stricter validation error messages now include field path for nested objects
+- Examples reorganized into categorized directories
+
+---
+
+## [1.0.0] - 2026-03-26
+
+### Core ORM
+
+- `Prorm` class as the primary entry point — accepts `dialect`, `database`, `username`,
+  `password`, `host`, `port`, `storage` (SQLite), `logging`, `pool`, and `dialectOptions`
+- `prorm.define(modelName, attributes, options)` for defining models
+- `Model.init(attributes, options)` static class-based model definition
+- `prorm.sync({ force?, alter? })` for creating or altering tables to match model definitions
+- `prorm.authenticate()` for testing the database connection
+- `prorm.close()` for gracefully shutting down all connections
+- `prorm.query(sql, options)` for raw SQL execution with `QueryTypes` enum
+- `prorm.transaction(callback)` managed transaction with automatic commit/rollback
+- `prorm.transaction()` manual transaction returned as a `Transaction` object
+- `Prorm` as event emitter for connection lifecycle events
+
+---
+
+[Unreleased]: https://gitlab.com/Malcolmston/prod-orm/-/compare/v1.0.0...HEAD
+[1.0.0]: https://gitlab.com/Malcolmston/prod-orm/-/releases/v1.0.0