orange-orm 4.7.10-beta.1 → 4.7.10-beta.3

package/src/map2.d.ts

@@ -1,4 +1,4 @@
-//map2.d.ts - Refactored Active Record Methods
+//map2.d.ts - Extended Row Types with Relations Support
 import type { PGliteOptions } from './pglite.d.ts';
 import type { ConnectionConfiguration } from 'tedious';
 import type { D1Database } from '@cloudflare/workers-types';
@@ -90,6 +90,7 @@ export type ColumnFilterType<Val, ColumnType = any> = {
   ne(value: Val | null | undefined): Filter;
   lessThan(value: Val | null | undefined): Filter;
   lt(value: Val | null | undefined): Filter;
+  lessThanOrEqual(value: Val | null | undefined): Filter;
   le(value: Val | null | undefined): Filter;
   greaterThan(value: Val | null | undefined): Filter;
   gt(value: Val | null | undefined): Filter;
@@ -207,13 +208,18 @@ type ValidColumnFilterTypes<M extends Record<string, TableDefinition<M>>, K exte
 
 // Column selection refs without filter methods - only for getting values/references
 type ColumnSelectionRefs<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
-  // Required columns (notNull = true)
-  [C in keyof M[K]['columns'] as IsRequired<M[K]['columns'][C]> extends true ? C : never]: ColumnTypeToTS<M[K]['columns'][C]>;
-} & {
-  // Optional columns (nullable)
-  [C in keyof M[K]['columns'] as IsRequired<M[K]['columns'][C]> extends true ? never : C]?: ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
+  [C in keyof M[K]['columns']]: M[K]['columns'][C];
 };
 
+
+// type ColumnSelectionRefs<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
+//   // Required columns (notNull = true)
+//   [C in keyof M[K]['columns'] as IsRequired<M[K]['columns'][C]> extends true ? C : never]: ColumnTypeToTS<M[K]['columns'][C]>;
+// } & {
+//   // Optional columns (nullable)
+//   [C in keyof M[K]['columns'] as IsRequired<M[K]['columns'][C]> extends true ? never : C]?: ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
+// };
+
 // Relation selection refs without filter methods - supports deep nesting
 // In selectors, all relation types just provide access to the target table structure
 // But WITHOUT aggregate functions (only available at root level)
@@ -544,6 +550,55 @@ type UpdateChangesRow<M extends Record<string, TableDefinition<M>>, K extends ke
     : ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
 };
 
+// NEW: Extended row types with relations support
+
+// Type for relation rows - only respects notNull, ignores notNullExceptInsert
+type RelationRow<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
+  // Required columns (notNull = true, ignoring notNullExceptInsert)
+  [C in keyof M[K]['columns'] as IsRequired<M[K]['columns'][C]> extends true ? C : never]: ColumnTypeToTS<M[K]['columns'][C]>;
+} & {
+  // Optional columns (all others)
+  [C in keyof M[K]['columns'] as IsRequired<M[K]['columns'][C]> extends true ? never : C]?: ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
+};
+
+// Helper type to create relation data for insert/update operations
+type RelationData<M extends Record<string, TableDefinition<M>>, K extends keyof M> =
+  M[K] extends { relations: infer R }
+  ? {
+    [RName in keyof R]?: R[RName] extends RelationDefinition<M>
+    ? R[RName]['type'] extends 'hasMany'
+    ? R[RName]['target'] extends keyof M
+    ? Array<RelationRowWithRelations<M, R[RName]['target']>>
+    : never
+    : R[RName]['type'] extends 'hasOne' | 'references'
+    ? R[RName]['target'] extends keyof M
+    ? RelationRowWithRelations<M, R[RName]['target']> | null
+    : never
+    : never
+    : never;
+  }
+  : {};
+
+// Relation row type with nested relations support
+type RelationRowWithRelations<M extends Record<string, TableDefinition<M>>, K extends keyof M> = 
+  RelationRow<M, K> & RelationData<M, K>;
+
+// Extended insert row type with optional relations
+type InsertRowWithRelations<M extends Record<string, TableDefinition<M>>, K extends keyof M> = 
+  InsertRow<M, K> & RelationData<M, K>;
+
+// Extended update/replace row type with optional relations
+type UpdateChangesRowWithRelations<M extends Record<string, TableDefinition<M>>, K extends keyof M> = 
+  UpdateChangesRow<M, K> & RelationData<M, K>;
+
+// Extended type for bulk update operations with optional relations
+type UpdateRowWithRelations<M extends Record<string, TableDefinition<M>>, K extends keyof M> = 
+  Partial<{
+    [C in keyof M[K]['columns']]: IsRequired<M[K]['columns'][C]> extends true
+    ? ColumnTypeToTS<M[K]['columns'][C]>
+    : ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
+  }> & RelationData<M, K>;
+
 // REFACTORED: Separate Active Record Methods for Individual Rows vs Arrays
 
 // Active record methods for individual rows
@@ -578,6 +633,45 @@ type WithActiveRecord<T, M extends Record<string, TableDefinition<M>>, K extends
 type WithArrayActiveRecord<T extends Array<any>, M extends Record<string, TableDefinition<M>>, K extends keyof M> =
   T & ArrayActiveRecordMethods<M, K>;
 
+// Separate CustomSelectorProperties for aggregate (allows column name overlap)
+type AggregateCustomSelectorProperties<M extends Record<string, TableDefinition<M>>, K extends keyof M, FS extends Record<string, any>> = {
+  // Required properties (count, sum, avg) - no question mark, no null/undefined
+  [P in keyof FS as
+    P extends ReservedFetchStrategyProps ? never :
+    P extends (M[K] extends { relations: infer R } ? keyof R : never) ? never :
+    FS[P] extends (row: any) => any ?
+      (FS[P] extends (row: RootSelectionRefs<M, K>) => infer ReturnType
+        ? IsRequiredAggregate<ReturnType> extends true
+          ? P  // Required aggregates
+          : never
+        : never)
+      : never
+  ]: FS[P] extends (row: RootSelectionRefs<M, K>) => infer ReturnType
+      ? number  // Required aggregate functions (count, sum, avg) return required number
+      : never;
+} & {
+  // Optional properties (max, min, plain columns) - with question mark AND null/undefined
+  [P in keyof FS as
+    P extends ReservedFetchStrategyProps ? never :
+    P extends (M[K] extends { relations: infer R } ? keyof R : never) ? never :
+    FS[P] extends (row: any) => any ?
+      (FS[P] extends (row: RootSelectionRefs<M, K>) => infer ReturnType
+        ? IsRequiredAggregate<ReturnType> extends true
+          ? never  // Required aggregates are not optional
+          : P  // Everything else is optional
+        : never)
+      : never
+  ]?: FS[P] extends (row: RootSelectionRefs<M, K>) => infer ReturnType
+        ? IsMinMaxAggregate<ReturnType> extends true
+          ? ExtractMinMaxColumnType<ReturnType> | null | undefined
+          : IsAggregateFunction<ReturnType> extends true
+            ? number | null | undefined
+            : ReturnType extends ORMColumnDefinition | ORMJsonColumnDefinition
+              ? ColumnDefinitionToTS<ReturnType> | null | undefined
+              : never
+        : never;
+};
+
 export type TableClient<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
   // Array methods - return arrays with array-level active record methods, but individual items are plain
   getAll(): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
@@ -586,7 +680,7 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   getMany<strategy extends FetchStrategy<M, K>>(filter: RawFilter | Array<PrimaryKeyObject<M, K>>, strategy: strategy): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
   // Aggregate methods - return plain objects (no active record methods)
-  aggregate<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<CustomSelectorProperties<M, K, strategy>>>>;
+  aggregate<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<AggregateCustomSelectorProperties<M, K, strategy>>>>;
 
   // Single item methods - return individual objects with individual active record methods
   getOne<strategy extends FetchStrategy<M, K>>(
@@ -606,22 +700,14 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
     ...args: [...PrimaryKeyArgs<M, K>]
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>;
 
-  // Bulk update methods
+  // UPDATED: Bulk update methods with relations support
   update(
-    row: Partial<{
-      [C in keyof M[K]['columns']]: IsRequired<M[K]['columns'][C]> extends true
-      ? ColumnTypeToTS<M[K]['columns'][C]>
-      : ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
-    }>,
+    row: UpdateRowWithRelations<M, K>,
     opts: { where: (row: RootTableRefs<M, K>) => RawFilter }
   ): Promise<void>;
 
   update<strategy extends FetchStrategy<M, K>>(
-    row: Partial<{
-      [C in keyof M[K]['columns']]: IsRequired<M[K]['columns'][C]> extends true
-      ? ColumnTypeToTS<M[K]['columns'][C]>
-      : ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
-    }>,
+    row: UpdateRowWithRelations<M, K>,
     opts: { where: (row: RootTableRefs<M, K>) => RawFilter },
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
@@ -631,87 +717,87 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   delete(filter: RawFilter | Array<PrimaryKeyObject<M, K>>,): Promise<void>;
   deleteCascade(filter: RawFilter | Array<PrimaryKeyObject<M, K>>,): Promise<void>;
 
-  // Replace methods - can return single or array with appropriate active record methods
+  // UPDATED: Replace methods with relations support
   replace(
-    row: Array<UpdateChangesRow<M, K>>
+    row: Array<UpdateChangesRowWithRelations<M, K>>
   ): Promise<void>;
 
   replace<strategy extends FetchStrategy<M, K>>(
-    row: UpdateChangesRow<M, K>,
+    row: UpdateChangesRowWithRelations<M, K>,
     strategy: strategy
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
 
   replace<strategy extends FetchStrategy<M, K>>(
-    rows: Array<UpdateChangesRow<M, K>>,
+    rows: Array<UpdateChangesRowWithRelations<M, K>>,
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
-  // UpdateChanges methods - can return single or array with appropriate active record methods
+  // UPDATED: UpdateChanges methods with relations support
   updateChanges(
-    row: UpdateChangesRow<M, K>,
-    originalRow: UpdateChangesRow<M, K>
+    row: UpdateChangesRowWithRelations<M, K>,
+    originalRow: UpdateChangesRowWithRelations<M, K>
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>;
 
   updateChanges(
-    rows: Array<UpdateChangesRow<M, K>>,
-    originalRows: Array<UpdateChangesRow<M, K>>
+    rows: Array<UpdateChangesRowWithRelations<M, K>>,
+    originalRows: Array<UpdateChangesRowWithRelations<M, K>>
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
 
   updateChanges<strategy extends FetchStrategy<M, K>>(
-    row: UpdateChangesRow<M, K>,
-    originalRow: UpdateChangesRow<M, K>,
+    row: UpdateChangesRowWithRelations<M, K>,
+    originalRow: UpdateChangesRowWithRelations<M, K>,
     strategy: strategy
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
 
   updateChanges<strategy extends FetchStrategy<M, K>>(
-    rows: Array<UpdateChangesRow<M, K>>,
-    originalRows: Array<UpdateChangesRow<M, K>>,
+    rows: Array<UpdateChangesRowWithRelations<M, K>>,
+    originalRows: Array<UpdateChangesRowWithRelations<M, K>>,
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
-  // Insert methods - no active record methods for insertAndForget, appropriate methods for others
+  // UPDATED: Insert methods with relations support - no active record methods for insertAndForget, appropriate methods for others
   insertAndForget(
-    row: InsertRow<M, K>
+    row: InsertRowWithRelations<M, K>
   ): Promise<void>;
 
   insertAndForget(
-    rows: Array<InsertRow<M, K>>
+    rows: Array<InsertRowWithRelations<M, K>>
   ): Promise<void>;
 
   insert(
-    row: InsertRow<M, K>
+    row: InsertRowWithRelations<M, K>
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>;
 
   insert(
-    rows: Array<InsertRow<M, K>>
+    rows: Array<InsertRowWithRelations<M, K>>
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
 
   insert<strategy extends FetchStrategy<M, K>>(
-    row: InsertRow<M, K>,
+    row: InsertRowWithRelations<M, K>,
     strategy: strategy
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
 
   insert<strategy extends FetchStrategy<M, K>>(
-    rows: Array<InsertRow<M, K>>,
+    rows: Array<InsertRowWithRelations<M, K>>,
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
-  // Proxify methods - can return single or array with appropriate active record methods
+  // UPDATED: Proxify methods with relations support
   proxify(
-    row: UpdateChangesRow<M, K>
+    row: UpdateChangesRowWithRelations<M, K>
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>;
 
   proxify(
-    rows: Array<UpdateChangesRow<M, K>>
+    rows: Array<UpdateChangesRowWithRelations<M, K>>
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
 
   proxify<strategy extends FetchStrategy<M, K>>(
-    row: UpdateChangesRow<M, K>,
+    row: UpdateChangesRowWithRelations<M, K>,
     strategy: strategy
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
 
   proxify<strategy extends FetchStrategy<M, K>>(
-    rows: Array<UpdateChangesRow<M, K>>,
+    rows: Array<UpdateChangesRowWithRelations<M, K>>,
     strategy: strategy
   ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 

package/src/cyclic.d.ts

@@ -1,132 +0,0 @@
-// Type definitions using a type mapping approach
-type EntityMap = {
-  Order: {
-    id: string;
-    date: Date;
-    total: number;
-  };
-  Line: {
-    id: string;
-    quantity: number;
-    price: number;
-  };
-  Package: {
-    id: string;
-    trackingNumber: string;
-    weight: number;
-  };
-  Customer: {
-    id: string;
-    name: string;
-    email: string;
-  };
-};
-
-// Enhanced relation mapping that includes cardinality information
-type RelationMap = {
-  Order: {
-    lines: { type: 'Line'; isArray: true };
-    customer: { type: 'Customer'; isArray: false };
-  };
-  Line: {
-    packages: { type: 'Package'; isArray: true };
-    order: { type: 'Order'; isArray: false };
-  };
-  Customer: {
-    orders: { type: 'Order'; isArray: true };
-  };
-  Package: {};
-};
-
-// Helper type to extract the entity type from a relation
-type RelationEntityType<R> = R extends { type: infer T extends keyof EntityMap } ? T : never;
-
-// Helper type to determine if a relation is an array
-type IsArray<R> = R extends { isArray: infer A extends boolean } ? A : false;
-
-// Generic deep type resolver
-type Depth = [never, 0, 1, 2, 3, 4, 5];
-
-// RecursiveType generic with improved depth handling
-type RecursiveType<
-  T extends keyof EntityMap,
-  D extends number = 5
-> = {
-  // Always include base properties
-  [K in keyof EntityMap[T]]: EntityMap[T][K];
-} & (D extends 0
-  ? // At max depth, only include base properties (which are already included above)
-    {}
-  : // Otherwise include relations with appropriate depth reduction
-    {
-      [K in keyof RelationMap[T]]: IsArray<RelationMap[T][K]> extends true
-        ? RecursiveType<
-            RelationEntityType<RelationMap[T][K]>,
-            Depth[D]
-          >[]
-        : RecursiveType<
-            RelationEntityType<RelationMap[T][K]>,
-            Depth[D]
-          >;
-    });
-
-// Generate the entity types with relationships resolved to the specified depth
-type Order = RecursiveType<'Order', 6>;
-
-type Line = RecursiveType<'Line'>;
-type Package = RecursiveType<'Package'>;
-type Customer = RecursiveType<'Customer'>;
-
-// Example usage
-function processOrder(order: Order, line: Line) {
-  // Can access nested properties up to depth 5
-  // const trackingNumber = order.customer.orders[0].lines[0].order.lines[0].packages[0].
-  // const orderId = order.customer.orders[0].customer.orders[0].lines[0].
-  line.order.customer.orders[0].lines[0].packages[0].
-  
-  console.log(trackingNumber, orderId);
-}
-
-// Allow custom depth control per entity type
-type OrderWithDepth1 = RecursiveType<'Order', 4>;
-
-// Example with custom depth
-function processOrderWithLimitedDepth(order: OrderWithDepth1) {
-  // This would work (depth 1)  
-
-  console.log(order.customer.id); // Can access base properties at max depth
-  console.log(order.customer.name); // Can access base properties at max depth
-  
-  // This would error - beyond depth 1
-  // console.log(order.customer.orders[0].id);
-}
-
-// Example of creating an instance with this type system
-const sampleOrder: Order = {
-  id: "ORD-123",
-  date: new Date(),
-  total: 299.99,
-  customer: {
-    id: "CUST-456",
-    name: "John Doe",
-    email: "john@example.com",
-    orders: [
-      /* would be recursive orders */
-    ]
-  },
-  lines: [
-    {
-      id: "LINE-789",
-      quantity: 2,
-      price: 149.99,
-      order: /* circular reference */,
-      packages: [
-        {
-          id: "PKG-101",
-          trackingNumber: "TRK123456789",
-          weight: 1.5
-        }
-      ]
-    }
-  ]
-};