orange-orm 4.7.10-beta.0 → 4.7.10-beta.2

package/src/map2.d.ts

@@ -1,4 +1,4 @@
-//map2.d.ts
+//map2.d.ts - Refactored Active Record Methods
 import type { PGliteOptions } from './pglite.d.ts';
 import type { ConnectionConfiguration } from 'tedious';
 import type { D1Database } from '@cloudflare/workers-types';
@@ -98,8 +98,6 @@ export type ColumnFilterType<Val, ColumnType = any> = {
   in(values: (Val | null | undefined)[]): Filter;
   between(from: Val | null | undefined, to: Val | null | undefined): Filter;
   notIn(values: (Val | null | undefined)[]): Filter;
-  // isNull(): Filter;
-  // isNotNull(): Filter;
 } & (ColumnType extends 'string' ? StringOnlyMethods : {});
 
 export type JsonArray = Array<JsonValue>;
@@ -209,14 +207,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)
@@ -378,9 +380,6 @@ type RequiredColumnKeys<M extends Record<string, TableDefinition<M>>, K extends
 type OptionalColumnKeys<M extends Record<string, TableDefinition<M>>, K extends keyof M, FS extends Record<string, any>> =
   Exclude<SelectedColumns<M, K, FS>, RequiredColumnKeys<M, K, FS>>;
 
-// Helper type to check if a value is actually a column reference from the row object
-// This is a bit of a hack - we check if the type has the structure of a ColumnFilterType
-// but without the filter methods (which is what ColumnSelectionRefs provides)
 type IsActualColumnReference<T, M extends Record<string, TableDefinition<M>>, K extends keyof M> =
   T extends ColumnTypeToTS<infer CT>
   ? CT extends ORMColumnDefinition | ORMJsonColumnDefinition
@@ -388,7 +387,6 @@ type IsActualColumnReference<T, M extends Record<string, TableDefinition<M>>, K
   : false
   : false;
 
-// Alternative approach: Check if the type matches what we'd get from accessing ColumnSelectionRefs
 type IsFromColumnSelectionRefs<M extends Record<string, TableDefinition<M>>, K extends keyof M, T = any> =
   T extends ColumnSelectionRefs<M, K>[keyof ColumnSelectionRefs<M, K>] ? true :
   T extends (M[K] extends { relations: infer R }
@@ -401,24 +399,19 @@ type IsFromColumnSelectionRefs<M extends Record<string, TableDefinition<M>>, K e
   T extends number ? true : // Allow aggregate function return type (number)
   false;
 
-// Helper type to infer the TypeScript type from selector return values
-// Only allows types that come from actual column selections or aggregate functions
 type InferSelectorReturnType<T, M extends Record<string, TableDefinition<M>>, K extends keyof M> =
   IsFromColumnSelectionRefs<M, K, T> extends true ? T : never;
 
-// ADD helper to check if return type is an aggregate function:
 type IsAggregateFunction<T> = T extends BaseAggregateFunction ? true : false;
 
 type IsRequiredAggregate<T> = T extends BaseAggregateFunction & { __functionType: infer FType }
   ? FType extends 'count' | 'sum' | 'avg' ? true : false
   : false;
 
-// Helper to check if it's a min/max function that should preserve column type
 type IsMinMaxAggregate<T> = T extends AggregateMinMaxFunction<any> & { __functionType: infer FType }
   ? FType extends 'max' | 'min' ? true : false
   : false;
 
-// Helper to extract the column type from min/max aggregate
 type ExtractMinMaxColumnType<T> = T extends AggregateMinMaxFunction<infer ColType>
   ? ColumnDefinitionToTS<ColType>
   : never;
@@ -556,7 +549,9 @@ type UpdateChangesRow<M extends Record<string, TableDefinition<M>>, K extends ke
     : ColumnTypeToTS<M[K]['columns'][C]> | null | undefined;
 };
 
-// Active record methods for top-level entities
+// REFACTORED: Separate Active Record Methods for Individual Rows vs Arrays
+
+// Active record methods for individual rows
 type ActiveRecordMethods<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
   saveChanges(): Promise<void>;
   saveChanges(concurrency: ConcurrencyConfig<M>[K]): Promise<void>;
@@ -568,18 +563,78 @@ type ActiveRecordMethods<M extends Record<string, TableDefinition<M>>, K extends
   delete<strategy extends FetchStrategy<M, K>>(strategy: strategy): Promise<void>;
 };
 
-// Helper type to add active record methods to selection results
+// Active record methods for arrays of rows
+type ArrayActiveRecordMethods<M extends Record<string, TableDefinition<M>>, K extends keyof M> = {
+  saveChanges(): Promise<void>;
+  saveChanges(concurrency: ConcurrencyConfig<M>[K]): Promise<void>;
+  acceptChanges(): void;
+  clearChanges(): void;
+  refresh(): Promise<void>;
+  refresh<strategy extends FetchStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<Selection<M, K, strategy>>>>;
+  delete(): Promise<void>;
+  delete<strategy extends FetchStrategy<M, K>>(strategy: strategy): Promise<void>;
+};
+
+// Helper type to add individual active record methods to selection results
 type WithActiveRecord<T, M extends Record<string, TableDefinition<M>>, K extends keyof M> =
   T & ActiveRecordMethods<M, K>;
 
+// Helper type to add array active record methods to arrays without adding them to individual items
+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> = {
-  getAll(): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>>;
-  getAll<strategy extends FetchStrategy<M, K>>(strategy: strategy): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
-  getMany(filter: RawFilter | Array<PrimaryKeyObject<M, K>>): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>>;
-  getMany<strategy extends FetchStrategy<M, K>>(filter: RawFilter | Array<PrimaryKeyObject<M, K>>, strategy: strategy): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
+  // 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>>;
+  getAll<strategy extends FetchStrategy<M, K>>(strategy: strategy): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
+  getMany(filter: RawFilter | Array<PrimaryKeyObject<M, K>>): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
+  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<AggregateCustomSelectorProperties<M, K, strategy>>>>;
 
-  aggregate<strategy extends AggregateStrategy<M, K>>(strategy: strategy): Promise<Array<DeepExpand<CustomSelectorProperties<M, K, strategy>>>>;
 
+
+  // Single item methods - return individual objects with individual active record methods
   getOne<strategy extends FetchStrategy<M, K>>(
     filter: RawFilter | Array<PrimaryKeyObject<M, K>>
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>;
@@ -597,6 +652,7 @@ 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
   update(
     row: Partial<{
       [C in keyof M[K]['columns']]: IsRequired<M[K]['columns'][C]> extends true
@@ -606,10 +662,6 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
     opts: { where: (row: RootTableRefs<M, K>) => RawFilter }
   ): Promise<void>;
 
-  count(filter: RawFilter | Array<PrimaryKeyObject<M, K>>,): Promise<number>;
-  delete(filter: RawFilter | Array<PrimaryKeyObject<M, K>>,): Promise<void>;
-  deleteCascade(filter: RawFilter | Array<PrimaryKeyObject<M, K>>,): Promise<void>;
-
   update<strategy extends FetchStrategy<M, K>>(
     row: Partial<{
       [C in keyof M[K]['columns']]: IsRequired<M[K]['columns'][C]> extends true
@@ -618,8 +670,14 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
     }>,
     opts: { where: (row: RootTableRefs<M, K>) => RawFilter },
     strategy: strategy
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
+
+  // Count and delete methods (no active record methods needed)
+  count(filter: RawFilter | Array<PrimaryKeyObject<M, K>>,): Promise<number>;
+  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
   replace(
     row: Array<UpdateChangesRow<M, K>>
   ): Promise<void>;
@@ -632,8 +690,9 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   replace<strategy extends FetchStrategy<M, K>>(
     rows: Array<UpdateChangesRow<M, K>>,
     strategy: strategy
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
+  // UpdateChanges methods - can return single or array with appropriate active record methods
   updateChanges(
     row: UpdateChangesRow<M, K>,
     originalRow: UpdateChangesRow<M, K>
@@ -642,7 +701,7 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   updateChanges(
     rows: Array<UpdateChangesRow<M, K>>,
     originalRows: Array<UpdateChangesRow<M, K>>
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
 
   updateChanges<strategy extends FetchStrategy<M, K>>(
     row: UpdateChangesRow<M, K>,
@@ -654,8 +713,9 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
     rows: Array<UpdateChangesRow<M, K>>,
     originalRows: Array<UpdateChangesRow<M, K>>,
     strategy: strategy
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
+  // Insert methods - no active record methods for insertAndForget, appropriate methods for others
   insertAndForget(
     row: InsertRow<M, K>
   ): Promise<void>;
@@ -670,7 +730,7 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
 
   insert(
     rows: Array<InsertRow<M, K>>
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
 
   insert<strategy extends FetchStrategy<M, K>>(
     row: InsertRow<M, K>,
@@ -680,15 +740,16 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   insert<strategy extends FetchStrategy<M, K>>(
     rows: Array<InsertRow<M, K>>,
     strategy: strategy
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
+  // Proxify methods - can return single or array with appropriate active record methods
   proxify(
     row: UpdateChangesRow<M, K>
   ): Promise<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>;
 
   proxify(
     rows: Array<UpdateChangesRow<M, K>>
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, {}>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, {}>>>, M, K>>;
 
   proxify<strategy extends FetchStrategy<M, K>>(
     row: UpdateChangesRow<M, K>,
@@ -698,14 +759,16 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   proxify<strategy extends FetchStrategy<M, K>>(
     rows: Array<UpdateChangesRow<M, K>>,
     strategy: strategy
-  ): Promise<Array<WithActiveRecord<DeepExpand<Selection<M, K, strategy>>, M, K>>>;
+  ): Promise<WithArrayActiveRecord<Array<DeepExpand<Selection<M, K, strategy>>>, M, K>>;
 
- patch<strategy extends FetchStrategy<M, K>>(
+  // Patch method
+  patch<strategy extends FetchStrategy<M, K>>(
     patches: JsonPatch,
     strategy: strategy,
     concurrency?: ConcurrencyConfig<M>[K]
   ): Promise<void>;
 
+  // TypeScript type helpers
   tsType(): DeepExpand<Selection<M, K, {}>>;
 
   tsType<strategy extends FetchStrategy<M, K>>(
@@ -713,6 +776,8 @@ export type TableClient<M extends Record<string, TableDefinition<M>>, K extends
   ): DeepExpand<Selection<M, K, strategy>>;
 };
 
+// Rest of the type definitions remain the same...
+
 export type ConcurrencyStrategy = 'optimistic' | 'overwrite' | 'skipOnConflict';
 
 export interface ColumnConcurrency {
@@ -740,15 +805,6 @@ export type DbOptions<M extends Record<string, TableDefinition<M>>> =
     db?: Pool | ((connectors: Connectors) => Pool | Promise<Pool>);
   };
 
-
-// type NegotiateDbInstance<T, C> = C extends WithDb
-// 	? DbConnectable<SchemaFromMappedDb<MappedDb<T>>>
-// 	: MappedDb<T>;
-
-// type WithDb = {
-// 	db: Pool | ((connectors: Connectors) => Pool | Promise<Pool>)
-// };
-
 export type DbConcurrency<M extends Record<string, TableDefinition<M>>> =
   ConcurrencyConfig<M>
   & ColumnConcurrency;
@@ -817,13 +873,12 @@ export type DBClient<M extends Record<string, TableDefinition<M>>> = {
   transaction(
 		fn: (db: DBClient<M>) => Promise<unknown>
 	): Promise<void>;
-  // saveChanges(arraysOrRow: { saveChanges(): Promise<void> }): Promise<void>;
   express(): import('express').RequestHandler;
   express(config: ExpressConfig<M>): import('express').RequestHandler;
   readonly metaData: DbConcurrency<M>;
 
   interceptors: WithInterceptors;
-} & WithInterceptors;
+} & WithInterceptors & DbConnectable<M>;
 
 type ExpressConfig<M extends Record<string, TableDefinition<M>>> = {
   [TableName in keyof M]?: ExpressTableConfig<M>;

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
-        }
-      ]
-    }
-  ]
-};