metal-orm 1.0.8 → 1.0.9

package/src/schema/relation.ts

@@ -1,69 +1,69 @@
-import { TableDef } from './table';
-
-/**
- * Types of relationships supported between tables
- */
-export const RelationKinds = {
-    /** One-to-many relationship */
-    HasMany: 'HAS_MANY',
-    /** Many-to-one relationship */
-    BelongsTo: 'BELONGS_TO',
-    /** Many-to-many relationship with pivot metadata */
-    BelongsToMany: 'BELONGS_TO_MANY'
-} as const;
-
-/**
- * Type representing the supported relationship kinds
- */
-export type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
-
-export type CascadeMode = 'none' | 'all' | 'persist' | 'remove' | 'link';
-
-/**
- * One-to-many relationship definition
- */
-export interface HasManyRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.HasMany;
-    target: TTarget;
-    foreignKey: string;
-    localKey?: string;
-    cascade?: CascadeMode;
-}
-
-/**
- * Many-to-one relationship definition
- */
-export interface BelongsToRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.BelongsTo;
-    target: TTarget;
-    foreignKey: string;
-    localKey?: string;
-    cascade?: CascadeMode;
-}
-
-/**
- * Many-to-many relationship definition with rich pivot metadata
- */
-export interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
-    type: typeof RelationKinds.BelongsToMany;
-    target: TTarget;
-    pivotTable: TableDef;
-    pivotForeignKeyToRoot: string;
-    pivotForeignKeyToTarget: string;
-    localKey?: string;
-    targetKey?: string;
-    pivotPrimaryKey?: string;
-    defaultPivotColumns?: string[];
-    cascade?: CascadeMode;
-}
-
-/**
- * Union type representing any supported relationship definition
- */
-export type RelationDef =
-  | HasManyRelation
-  | BelongsToRelation
-  | BelongsToManyRelation;
+import { TableDef } from './table.js';
+
+/**
+ * Types of relationships supported between tables
+ */
+export const RelationKinds = {
+    /** One-to-many relationship */
+    HasMany: 'HAS_MANY',
+    /** Many-to-one relationship */
+    BelongsTo: 'BELONGS_TO',
+    /** Many-to-many relationship with pivot metadata */
+    BelongsToMany: 'BELONGS_TO_MANY'
+} as const;
+
+/**
+ * Type representing the supported relationship kinds
+ */
+export type RelationType = (typeof RelationKinds)[keyof typeof RelationKinds];
+
+export type CascadeMode = 'none' | 'all' | 'persist' | 'remove' | 'link';
+
+/**
+ * One-to-many relationship definition
+ */
+export interface HasManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.HasMany;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+
+/**
+ * Many-to-one relationship definition
+ */
+export interface BelongsToRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.BelongsTo;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
+
+/**
+ * Many-to-many relationship definition with rich pivot metadata
+ */
+export interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.BelongsToMany;
+    target: TTarget;
+    pivotTable: TableDef;
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+}
+
+/**
+ * Union type representing any supported relationship definition
+ */
+export type RelationDef =
+  | HasManyRelation
+  | BelongsToRelation
+  | BelongsToManyRelation;
 
 /**
  * Creates a one-to-many relationship definition
@@ -77,18 +77,18 @@ export type RelationDef =
  * hasMany(usersTable, 'user_id')
  * ```
  */
-export const hasMany = <TTarget extends TableDef>(
-  target: TTarget,
-  foreignKey: string,
-  localKey?: string,
-  cascade?: CascadeMode
-): HasManyRelation<TTarget> => ({
-    type: RelationKinds.HasMany,
-    target,
-    foreignKey,
-    localKey,
-    cascade
-});
+export const hasMany = <TTarget extends TableDef>(
+  target: TTarget,
+  foreignKey: string,
+  localKey?: string,
+  cascade?: CascadeMode
+): HasManyRelation<TTarget> => ({
+    type: RelationKinds.HasMany,
+    target,
+    foreignKey,
+    localKey,
+    cascade
+});
 
 /**
  * Creates a many-to-one relationship definition
@@ -102,18 +102,18 @@ export const hasMany = <TTarget extends TableDef>(
  * belongsTo(usersTable, 'user_id')
  * ```
  */
-export const belongsTo = <TTarget extends TableDef>(
-  target: TTarget,
-  foreignKey: string,
-  localKey?: string,
-  cascade?: CascadeMode
-): BelongsToRelation<TTarget> => ({
-    type: RelationKinds.BelongsTo,
-    target,
-    foreignKey,
-    localKey,
-    cascade
-});
+export const belongsTo = <TTarget extends TableDef>(
+  target: TTarget,
+  foreignKey: string,
+  localKey?: string,
+  cascade?: CascadeMode
+): BelongsToRelation<TTarget> => ({
+    type: RelationKinds.BelongsTo,
+    target,
+    foreignKey,
+    localKey,
+    cascade
+});
 
 /**
  * Creates a many-to-many relationship definition with pivot metadata
@@ -122,29 +122,29 @@ export const belongsTo = <TTarget extends TableDef>(
  * @param options - Pivot metadata configuration
  * @returns BelongsToManyRelation definition
  */
-export const belongsToMany = <
-  TTarget extends TableDef
->(
-  target: TTarget,
-  pivotTable: TableDef,
-  options: {
-    pivotForeignKeyToRoot: string;
-    pivotForeignKeyToTarget: string;
-    localKey?: string;
-    targetKey?: string;
-    pivotPrimaryKey?: string;
-    defaultPivotColumns?: string[];
-    cascade?: CascadeMode;
-  }
-): BelongsToManyRelation<TTarget> => ({
-    type: RelationKinds.BelongsToMany,
-    target,
-    pivotTable,
-    pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
-    pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
-    localKey: options.localKey,
-    targetKey: options.targetKey,
-    pivotPrimaryKey: options.pivotPrimaryKey,
-    defaultPivotColumns: options.defaultPivotColumns,
-    cascade: options.cascade
-});
+export const belongsToMany = <
+  TTarget extends TableDef
+>(
+  target: TTarget,
+  pivotTable: TableDef,
+  options: {
+    pivotForeignKeyToRoot: string;
+    pivotForeignKeyToTarget: string;
+    localKey?: string;
+    targetKey?: string;
+    pivotPrimaryKey?: string;
+    defaultPivotColumns?: string[];
+    cascade?: CascadeMode;
+  }
+): BelongsToManyRelation<TTarget> => ({
+    type: RelationKinds.BelongsToMany,
+    target,
+    pivotTable,
+    pivotForeignKeyToRoot: options.pivotForeignKeyToRoot,
+    pivotForeignKeyToTarget: options.pivotForeignKeyToTarget,
+    localKey: options.localKey,
+    targetKey: options.targetKey,
+    pivotPrimaryKey: options.pivotPrimaryKey,
+    defaultPivotColumns: options.defaultPivotColumns,
+    cascade: options.cascade
+});

package/src/schema/table.ts

@@ -1,29 +1,29 @@
-import { ColumnDef } from './column';
-import { RelationDef } from './relation';
-
-export interface TableHooks {
-  beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
-  afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
-  beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-  afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-  beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
-  afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
-}
-
-/**
- * Definition of a database table with its columns and relationships
- * @typeParam T - Type of the columns record
- */
-export interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
-  /** Name of the table */
-  name: string;
-  /** Record of column definitions keyed by column name */
-  columns: T;
-  /** Record of relationship definitions keyed by relation name */
-  relations: Record<string, RelationDef>;
-  /** Optional lifecycle hooks */
-  hooks?: TableHooks;
-}
+import { ColumnDef } from './column.js';
+import { RelationDef } from './relation.js';
+
+export interface TableHooks {
+  beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
+  afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
+  beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+  afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+  beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
+  afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
+}
+
+/**
+ * Definition of a database table with its columns and relationships
+ * @typeParam T - Type of the columns record
+ */
+export interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
+  /** Name of the table */
+  name: string;
+  /** Record of column definitions keyed by column name */
+  columns: T;
+  /** Record of relationship definitions keyed by relation name */
+  relations: Record<string, RelationDef>;
+  /** Optional lifecycle hooks */
+  hooks?: TableHooks;
+}
 
 /**
  * Creates a table definition with columns and relationships
@@ -42,17 +42,17 @@ export interface TableDef<T extends Record<string, ColumnDef> = Record<string, C
  * });
  * ```
  */
-export const defineTable = <T extends Record<string, ColumnDef>>(
-    name: string,
-    columns: T,
-    relations: Record<string, RelationDef> = {},
-    hooks?: TableHooks
-): TableDef<T> => {
+export const defineTable = <T extends Record<string, ColumnDef>>(
+    name: string,
+    columns: T,
+    relations: Record<string, RelationDef> = {},
+    hooks?: TableHooks
+): TableDef<T> => {
   // Runtime mutability to assign names to column definitions for convenience
   const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
     (acc as any)[key] = { ...def, name: key, table: name };
     return acc;
   }, {} as T);
 
-  return { name, columns: colsWithNames, relations, hooks };
-};
+  return { name, columns: colsWithNames, relations, hooks };
+};

package/src/schema/types.ts

@@ -1,76 +1,76 @@
-import { ColumnDef } from './column';
-import { TableDef } from './table';
-import {
-  RelationDef,
-  HasManyRelation,
-  BelongsToRelation,
-  BelongsToManyRelation
-} from './relation';
-
-/**
- * Maps a ColumnDef to its TypeScript type representation
- */
-export type ColumnToTs<T extends ColumnDef> =
-  T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
-  T['type'] extends 'BOOLEAN' | 'boolean' ? boolean :
-  T['type'] extends 'JSON' | 'json' ? unknown :
-  string;
-
-/**
- * Infers a row shape from a table definition
- */
-export type InferRow<TTable extends TableDef> = {
-  [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
-};
-
-type RelationResult<T extends RelationDef> =
-  T extends HasManyRelation<infer TTarget>        ? InferRow<TTarget>[] :
-  T extends BelongsToRelation<infer TTarget>      ? InferRow<TTarget> | null :
-  T extends BelongsToManyRelation<infer TTarget>  ? (InferRow<TTarget> & { _pivot?: any })[] :
-  never;
-
-/**
- * Maps relation names to the expected row results
- */
-export type RelationMap<TTable extends TableDef> = {
-  [K in keyof TTable['relations']]: RelationResult<TTable['relations'][K]>;
-};
-
-export interface HasManyCollection<TChild> {
-  load(): Promise<TChild[]>;
-  getItems(): TChild[];
-  add(data: Partial<TChild>): TChild;
-  attach(entity: TChild): void;
-  remove(entity: TChild): void;
-  clear(): void;
-}
-
-export interface BelongsToReference<TParent> {
-  load(): Promise<TParent | null>;
-  get(): TParent | null;
-  set(data: Partial<TParent> | TParent | null): TParent | null;
-}
-
-export interface ManyToManyCollection<TTarget> {
-  load(): Promise<TTarget[]>;
-  getItems(): TTarget[];
-  attach(target: TTarget | number | string): void;
-  detach(target: TTarget | number | string): void;
-  syncByIds(ids: (number | string)[]): Promise<void>;
-}
-
-export type Entity<
-  TTable extends TableDef,
-  TRow = InferRow<TTable>
-> = TRow & {
-  [K in keyof RelationMap<TTable>]:
-    TTable['relations'][K] extends HasManyRelation<infer TTarget>
-      ? HasManyCollection<Entity<TTarget>>
-      : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget>
-        ? ManyToManyCollection<Entity<TTarget>>
-        : TTable['relations'][K] extends BelongsToRelation<infer TTarget>
-          ? BelongsToReference<Entity<TTarget>>
-          : never;
-} & {
-  $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
-};
+import { ColumnDef } from './column.js';
+import { TableDef } from './table.js';
+import {
+  RelationDef,
+  HasManyRelation,
+  BelongsToRelation,
+  BelongsToManyRelation
+} from './relation.js';
+
+/**
+ * Maps a ColumnDef to its TypeScript type representation
+ */
+export type ColumnToTs<T extends ColumnDef> =
+  T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
+  T['type'] extends 'BOOLEAN' | 'boolean' ? boolean :
+  T['type'] extends 'JSON' | 'json' ? unknown :
+  string;
+
+/**
+ * Infers a row shape from a table definition
+ */
+export type InferRow<TTable extends TableDef> = {
+  [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
+};
+
+type RelationResult<T extends RelationDef> =
+  T extends HasManyRelation<infer TTarget>        ? InferRow<TTarget>[] :
+  T extends BelongsToRelation<infer TTarget>      ? InferRow<TTarget> | null :
+  T extends BelongsToManyRelation<infer TTarget>  ? (InferRow<TTarget> & { _pivot?: any })[] :
+  never;
+
+/**
+ * Maps relation names to the expected row results
+ */
+export type RelationMap<TTable extends TableDef> = {
+  [K in keyof TTable['relations']]: RelationResult<TTable['relations'][K]>;
+};
+
+export interface HasManyCollection<TChild> {
+  load(): Promise<TChild[]>;
+  getItems(): TChild[];
+  add(data: Partial<TChild>): TChild;
+  attach(entity: TChild): void;
+  remove(entity: TChild): void;
+  clear(): void;
+}
+
+export interface BelongsToReference<TParent> {
+  load(): Promise<TParent | null>;
+  get(): TParent | null;
+  set(data: Partial<TParent> | TParent | null): TParent | null;
+}
+
+export interface ManyToManyCollection<TTarget> {
+  load(): Promise<TTarget[]>;
+  getItems(): TTarget[];
+  attach(target: TTarget | number | string): void;
+  detach(target: TTarget | number | string): void;
+  syncByIds(ids: (number | string)[]): Promise<void>;
+}
+
+export type Entity<
+  TTable extends TableDef,
+  TRow = InferRow<TTable>
+> = TRow & {
+  [K in keyof RelationMap<TTable>]:
+    TTable['relations'][K] extends HasManyRelation<infer TTarget>
+      ? HasManyCollection<Entity<TTarget>>
+      : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget>
+        ? ManyToManyCollection<Entity<TTarget>>
+        : TTable['relations'][K] extends BelongsToRelation<infer TTarget>
+          ? BelongsToReference<Entity<TTarget>>
+          : never;
+} & {
+  $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
+};

package/.github/workflows/publish-metal-orm.yml

@@ -1,38 +0,0 @@
-name: Publish metal-orm to npm
-
-on:
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: read
-  id-token: write    # OIDC for Trusted Publishing
-  packages: write
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install deps
-        run: npm ci
-
-      - name: Test
-        run: npm test
-        continue-on-error: true  # ou remove se quiser quebrar se falhar
-
-      - name: Build
-        run: npm run build
-
-      - name: Publish (Trusted Publishing)
-        run: npm publish --provenance --access public

package/ROADMAP.md

@@ -1,125 +0,0 @@
-# Metal ORM Roadmap
-
-## Current ORM Capabilities
-
-The current implementation supports:
-
-- Basic SELECT with projections and aliases
-- INNER/LEFT JOINs with manual conditions
-- Smart relationship joins via `joinRelation()`
-- Eager loading with `include()` for 1:1 and 1:N relationships
-- Basic WHERE clauses with operators (eq, gt, like, in, null checks)
-- GROUP BY, ORDER BY, LIMIT, OFFSET
-- Aggregation functions (COUNT, SUM, AVG)
-- JSON path extraction (dialect-specific)
-- Hydration of nested objects from flat SQL results
-- EXISTS and NOT EXISTS subqueries
-- Scalar correlated subqueries in SELECT and WHERE
-- CASE expressions (simple and searched)
-- HAVING clause for post-aggregation filtering
-
-## Identified Absences
-
-### 1. CTE (Common Table Expressions) ✅
-
-**Completed:** Full CTE support has been implemented
-
-- Features: Simple CTEs, Recursive CTEs, Multiple CTEs, CTE with column aliases
-- **Implementation:** CTE AST node and dialect compilation for SQLite, MySQL, and MSSQL
-- Recursive CTEs properly handle the `WITH RECURSIVE` keyword (SQLite/MySQL only, MSSQL uses plain `WITH`)
-- Mixed recursive and non-recursive CTEs are supported
-
-### 2. Window Functions ✅
-
-**Completed:** Comprehensive window function support has been implemented
-
-- Features: `ROW_NUMBER()`, `RANK()`, `DENSE_RANK()`, `LAG()`, `LEAD()`, `NTILE()`, `FIRST_VALUE()`, `LAST_VALUE()`
-- **Implementation:** Window function AST nodes with `PARTITION BY` and `ORDER BY` support
-- All three dialects (SQLite, MySQL, MSSQL) support window functions
-
-### 3. RIGHT JOIN Support
-
-**Missing:** Only INNER, LEFT, and CROSS joins are defined
-
-- **Required Addition:** RIGHT JOIN support in join.ts and dialect compilation
-
-### 4. Complex Aggregation Functions
-
-**Missing:** Limited aggregation functions
-
-- Queries: `5-top-platform-contributor-per-project`, `5-mega-user-engagement-analytics`
-- **Required Addition:** MIN, MAX, AVG functions, and GROUP_CONCAT
-
-### 5. Parameterized Queries
-
-**Missing:** No parameter binding support
-
-- Queries: `1-1-parameterized-user-by-twitter`
-- **Required Addition:** Parameter placeholder support and binding mechanism
-
-### 6. Advanced JSON Operations
-
-**Missing:** Limited JSON functionality
-
-- Queries: `1-1-profile-json-as-subquery-column`, `5-mega-user-engagement-analytics`
-- **Required Addition:** JSON_OBJECT, JSON_ARRAYAGG functions
-
-### 7. Recursive CTEs ✅
-
-**Completed:** See Section 1 (CTE) above
-
-- Recursive CTEs are fully supported as part of the CTE implementation
-
-### 8. Complex Ordering
-
-**Missing:** Limited ORDER BY expressions
-
-- Queries: `1-1-order-by-subquery-profile-field`, `5-mega-user-engagement-analytics`
-- **Required Addition:** ORDER BY with expressions and NULLS FIRST/LAST
-
-### 9. DISTINCT ON (PostgreSQL-style)
-
-**Missing:** No DISTINCT ON support
-
-- **Required Addition:** Dialect-specific DISTINCT ON compilation
-
-### 10. Subquery Aliasing
-
-**Missing:** No support for subqueries as derived tables
-
-- **Required Addition:** Derived table AST node
-
-### 11. Advanced EXISTS Patterns
-
-**Missing:** EXISTS with complex correlated subqueries
-
-- Queries: `1-1-boolean-flag-from-subquery-on-profile`
-- **Required Addition:** Complex correlation support
-
-## Priority Implementation Order
-
-### Completed ✅
-
-- ~~CTE support~~ (Completed)
-- ~~Window functions~~ (Completed)
-- ~~Recursive CTEs~~ (Completed)
-
-### High Priority:
-
-- Parameterized queries
-- RIGHT JOIN
-- Complex aggregation functions (MIN, MAX, GROUP_CONCAT)
-
-### Medium Priority:
-
-- Advanced JSON operations
-- Complex ordering (expressions, NULLS FIRST/LAST)
-
-### Lower Priority:
-
-- Subquery Aliasing (Derived tables)
-- Advanced EXISTS Patterns
-
-## Implementation Notes
-
-The current ORM is well-architected with a clear AST structure and dialect abstraction, making it relatively straightforward to add these missing features by extending the existing patterns.