@archlast/server 0.1.7 → 0.1.9

package/dist/services/admin/data.service.js

@@ -183,6 +183,7 @@ function createAdminDataService() {
                 const collectionNames = schema?.tables ? Object.keys(schema.tables) : [];
                 // Create a wrapper function that creates DbSet with proper dependencies
                 const createDbSetWrapper = (collection, changeTracker) => {
+                    // Return DbSet<DataModel[K]>
                     const { QueryProvider } = require("../../repository/provider.js");
                     const { MutableQueryable } = require("../../repository/queryable.js");
                     const collectionName = String(collection);
@@ -209,20 +210,20 @@ function createAdminDataService() {
                 // Create the script function using AsyncFunction
                 const AsyncFunction = Object.getPrototypeOf(async function () { })
                     .constructor;
-                const scriptFn = new AsyncFunction("ctx", "console", `
-                        "use strict";
-                        const { repository, List, logger, collections } = ctx;
-                        try {
-                            ${code}
-                        } catch (error) {
-                            return { error: error instanceof Error ? error.message : String(error) };
-                        }
+                const scriptFn = new AsyncFunction("ctx", "console", `
+                        "use strict";
+                        const { repository, List, logger, collections } = ctx;
+                        try {
+                            ${code}
+                        } catch (error) {
+                            return { error: error instanceof Error ? error.message : String(error) };
+                        }
                         `);
                 // Create a safe console proxy
                 const logs = [];
                 const safeConsole = {
                     log: (...args) => logs.push(args
-                        .map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+                        .map((a) => (typeof a === "object" ? JSON.stringify(a) : String(a)))
                         .join(" ")),
                     error: (...args) => logs.push("[ERROR] " +
                         args
@@ -436,283 +437,283 @@ function createAdminDataService() {
             withRelationsInterfaces.push(generateWithRelationsInterface(name, tableDef, tables));
         }
         // Generate TypeScript definitions for the LINQ-style repository API with EF Core and linqts
-        const typeDefinitions = `${documentInterfaces.join("\n\n")}
-
-// ==================== Input Types (Create/Update) ====================
-
-${createInputInterfaces.join("\n\n")}
-
-${updateInputInterfaces.join("\n\n")}
-
-// ==================== Relationship Types ====================
-
-${withRelationsInterfaces.join("\n\n")}
-
-// ==================== LINQ Query Types ====================
-
-type Predicate<T> = (item: T) => boolean | Promise<boolean>;
-type Projection<TSource, TResult> = (item: TSource) => TResult;
-
-type WhereOperator<T> =
-    | { eq: T }
-    | { ne: T }
-    | { gt: T }
-    | { gte: T }
-    | { lt: T }
-    | { lte: T }
-    | { in: T[] }
-    | { notIn: T[] }
-    | { contains: string }
-    | { startsWith: string }
-    | { endsWith: string }
-    | { isNull: true }
-    | { isNotNull: true };
-
-type WhereClause<T> = {
-    [K in keyof T]?: T[K] | WhereOperator<T[K]> | { and: WhereClause<T>[] } | { or: WhereClause<T>[] } | { not: WhereClause<T> };
-};
-
-type OrderByClause<T> = {
-    [K in keyof T]?: "asc" | "desc";
-};
-
-// ==================== Queryable Interfaces ====================
-
-/**
- * Async enumerable for streaming query results without loading all into memory
- * Provides O(1) memory usage vs O(n) for ToArrayAsync and supports early termination
- */
-declare interface IAsyncEnumerable<T> {
-    /** Async iterator for for await...of loops */
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-    /** Filter items based on predicate */
-    Where(predicate: (item: T) => boolean): IAsyncEnumerable<T>;
-    /** Project items to new form */
-    Select<TResult>(selector: (item: T) => TResult): IAsyncEnumerable<TResult>;
-    /** Take first n items (supports early termination) */
-    Take(count: number): IAsyncEnumerable<T>;
-    /** Skip first n items */
-    Skip(count: number): IAsyncEnumerable<T>;
-    /** Materialize all items to array (loads entire set into memory) */
-    ToArrayAsync(): Promise<T[]>;
-    /** Get first item or throw if empty */
-    FirstAsync(): Promise<T>;
-    /** Get first item or undefined if empty */
-    FirstOrDefaultAsync(): Promise<T | undefined>;
-    /** Count items in sequence */
-    CountAsync(): Promise<number>;
-    /** Check if any item exists (short-circuits on first item) */
-    AnyAsync(): Promise<boolean>;
-}
-
-declare interface IQueryable<T> {
-    Where(where: WhereClause<T> | Predicate<T>): IQueryable<T>;
-    Select<TResult>(selector: Projection<T, TResult>): IQueryable<TResult>;
-    SelectMany<TResult>(selector: (item: T) => IQueryable<TResult> | TResult[]): IQueryable<TResult>;
-    OrderBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
-    OrderByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
-    Take(count: number): IQueryable<T>;
-    Skip(count: number): IQueryable<T>;
-    Distinct(): IQueryable<T>;
-    CountAsync(): Promise<number>;
-    CountAsync(predicate: Predicate<T>): Promise<number>;
-    AnyAsync(): Promise<boolean>;
-    AnyAsync(predicate: Predicate<T>): Promise<boolean>;
-    AllAsync(predicate: Predicate<T>): Promise<boolean>;
-    FirstAsync(): Promise<T>;
-    FirstAsync(predicate: Predicate<T>): Promise<T>;
-    FirstOrDefaultAsync(): Promise<T | undefined>;
-    FirstOrDefaultAsync(predicate: Predicate<T>): Promise<T | undefined>;
-    ToListAsync(): Promise<List<T>>;
-    ToArrayAsync(): Promise<T[]>;
-    /** Returns an async enumerable for streaming without loading all items into memory */
-    AsAsyncEnumerable(): IAsyncEnumerable<T>;
-}
-
-declare interface IOrderedQueryable<T> extends IQueryable<T> {
-    ThenBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
-    ThenByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
-}
-
-declare interface IMutableQueryable<T, TCreateInput = Omit<T, "_id" | "_collection">> extends IQueryable<T> {
-    Where(where: WhereClause<T> | Predicate<T>): IMutableQueryable<T, TCreateInput>;
-    Select<TResult>(selector: Projection<T, TResult>): IMutableQueryable<TResult, any>;
-    Take(count: number): IMutableQueryable<T, TCreateInput>;
-    Skip(count: number): IMutableQueryable<T, TCreateInput>;
-    Distinct(): IMutableQueryable<T, TCreateInput>;
-    OrderBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
-    OrderByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
-    Insert(data: TCreateInput | Omit<T, "_id" | "_collection">): Promise<string>;
-    InsertMany(data: (TCreateInput | Omit<T, "_id" | "_collection">)[]): Promise<string[]>;
-    UpdateMany(data: Partial<Omit<T, "_id" | "_collection">>): Promise<number>;
-    DeleteMany(): Promise<number>;
-    AsNoTracking(): IQueryable<T>;
-    AsAsyncEnumerable(): IAsyncEnumerable<T>;
-}
-
-declare interface IOrderedMutableQueryable<T, TCreateInput = Omit<T, "_id" | "_collection">> extends IOrderedQueryable<T>, IMutableQueryable<T, TCreateInput> {
-    ThenBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
-    ThenByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
-}
-
-// ==================== EF Core Types ====================
-
-declare enum EntityState {
-    Detached = 0,
-    Unchanged = 1,
-    Deleted = 2,
-    Modified = 3,
-    Added = 4,
-}
-
-declare interface IEntityEntry<T> {
-    readonly entity: T;
-    readonly state: EntityState;
-    readonly originalValues: Partial<T>;
-    readonly id: string | undefined;
-    detach(): void;
-    markDeleted(): void;
-    markModified(): void;
-}
-
-declare interface IChangeTracker {
-    track<T>(collection: string, entity: T, state?: EntityState): IEntityEntry<T>;
-    getEntry<T>(collection: string, id: string | undefined, entity?: T): IEntityEntry<T> | undefined;
-    entries(state?: EntityState): IEntityEntry<unknown>[];
-    hasChanges(): boolean;
-    entriesByCollection(): Map<string, IEntityEntry<unknown>[]>;
-    acceptAllChanges(): void;
-    clear(): void;
-}
-
-declare interface IDbSet<
-    T,
-    TCreateInput = Omit<T, "_id" | "_collection">,
-    TUpdateInput = Partial<Omit<T, "_id" | "_collection">>
-> extends IMutableQueryable<T, TCreateInput> {
-    /** Track entity as Added (will INSERT on SaveChangesAsync) - accepts full entity or CreateInput */
-    Add(entity: T | TCreateInput): IEntityEntry<T>;
-    /** Track multiple entities as Added */
-    AddRange(entities: (T | TCreateInput)[]): IEntityEntry<T>[];
-    /** Mark entity for deletion (will DELETE on SaveChangesAsync) */
-    Remove(entity: T): IEntityEntry<T> | undefined;
-    /** Mark entity as Modified (will UPDATE on SaveChangesAsync) - accepts full entity or UpdateInput */
-    Update(entity: T | TUpdateInput): IEntityEntry<T> | undefined;
-    /** Immediately execute UPDATE without change tracking */
-    ExecuteUpdateAsync(update: TUpdateInput | Partial<Omit<T, "_id" | "_collection">>): Promise<number>;
-    /** Immediately execute DELETE without change tracking */
-    ExecuteDeleteAsync(): Promise<number>;
-    /** Return queryable without change tracking */
-    AsNoTracking(): IQueryable<T>;
-    /** Find entity by primary key - checks ChangeTracker cache first, then queries database */
-    FindAsync(id: string): Promise<T | undefined>;
-    /** Find entity by primary key from ChangeTracker cache only (synchronous, no DB query) */
-    Find(id: string): T | undefined;
-    /** Attach existing entity as Unchanged for selective updates */
-    Attach(entity: T): IEntityEntry<T>;
-    /** Attach multiple existing entities as Unchanged */
-    AttachRange(entities: T[]): IEntityEntry<T>[];
-    /** Returns async enumerable for streaming */
-    AsAsyncEnumerable(): IAsyncEnumerable<T>;
-}
-
-declare interface IDbContext<DataModel extends Record<string, any>> {
-    readonly ChangeTracker: IChangeTracker;
-    Set<K extends keyof DataModel & string>(collection: K): IDbSet<DataModel[K]>;
-    SaveChangesAsync(): Promise<number>;
-    /** Get EntityEntry for tracked entity using reference equality */
-    Entry<T>(entity: T): IEntityEntry<T> | undefined;
-}
-
-// ==================== linqts List<T> Class ====================
-
-declare class List<T> implements Iterable<T> {
-    constructor(items?: T[] | Iterable<T>);
-
-    // LINQ Methods
-    Where(predicate: (item: T) => boolean): List<T>;
-    Select<TResult>(selector: (item: T) => TResult): List<TResult>;
-    SelectMany<TResult>(selector: (item: T) => TResult[] | Iterable<TResult>): List<TResult>;
-    First(): T;
-    First(predicate: (item: T) => boolean): T;
-    FirstOrDefault(): T | undefined;
-    FirstOrDefault(predicate: (item: T) => boolean): T | undefined;
-    Last(): T;
-    Last(predicate: (item: T) => boolean): T;
-    LastOrDefault(): T | undefined;
-    LastOrDefault(predicate: (item: T) => boolean): T | undefined;
-    ElementAt(index: number): T;
-    ElementAtOrDefault(index: number): T | undefined;
-    Any(predicate?: (item: T) => boolean): boolean;
-    All(predicate: (item: T) => boolean): boolean;
-    Contains(item: T): boolean;
-    Count(): number;
-    Count(predicate: (item: T) => boolean): number;
-    Sum(selector?: (item: T) => number): number;
-    Average(selector?: (item: T) => number): number;
-    Min(selector?: (item: T) => number): number;
-    Max(selector?: (item: T) => number): number;
-    OrderBy(keySelector: (item: T) => any): List<T>;
-    OrderByDescending(keySelector: (item: T) => any): List<T>;
-    ThenBy(keySelector: (item: T) => any): List<T>;
-    ThenByDescending(keySelector: (item: T) => any): List<T>;
-    GroupBy<TKey>(keySelector: (item: T) => TKey): Record<string, T[]>;
-    Distinct(): List<T>;
-    Union(other: List<T>): List<T>;
-    Intersect(other: List<T>): List<T>;
-    Except(other: List<T>): List<T>;
-    Take(count: number): List<T>;
-    Skip(count: number): List<T>;
-    TakeWhile(predicate: (item: T) => boolean): List<T>;
-    SkipWhile(predicate: (item: T) => boolean): List<T>;
-    Reverse(): List<T>;
-    ToArray(): T[];
-    ToList(): List<T>;
-
-    // Mutation methods
-    Add(item: T): List<T>;
-    AddRange(items: T[]): List<T>;
-    Insert(index: number, item: T): List<T>;
-    Remove(item: T): boolean;
-    RemoveAt(index: number): void;
-    RemoveAll(predicate: (item: T) => boolean): number;
-    Clear(): void;
-
-    // Iteration
-    forEach(action: (item: T, index: number) => void): void;
-    map<TResult>(selector: (item: T, index: number) => TResult): TResult[];
-    filter(predicate: (item: T) => boolean): T[];
-    reduce<TResult>(accumulator: (acc: TResult, item: T) => TResult, initial: TResult): TResult;
-
-    // Iterator
-    [Symbol.iterator](): Iterator<T>;
-}
-
-// ==================== Repository & DbContext ====================
-
-declare interface Repository {
-    ${collectionNames.map((name) => `    ${name}: IDbSet<${capitalize(name)}Document, ${capitalize(name)}CreateInput, ${capitalize(name)}UpdateInput>;`).join("\n    ")}
-    readonly ChangeTracker: IChangeTracker;
-    SaveChangesAsync(): Promise<number>;
-}
-
-declare interface LoggerService {
-    log(data: { timestamp?: number; level: string; kind: string; message: string; context?: any }): void;
-}
-
-declare interface ScriptContext {
-    repository: Repository & IDbContext<any>;
-    List: typeof List;
-    logger: LoggerService;
-    collections: string[];
-}
-
-// Global declarations for the Action Editor
-declare const repository: Repository;
-declare const List: typeof List;
-declare const logger: LoggerService;
-declare const collections: string[];
-declare const ctx: ScriptContext;
+        const typeDefinitions = `${documentInterfaces.join("\n\n")}
+
+// ==================== Input Types (Create/Update) ====================
+
+${createInputInterfaces.join("\n\n")}
+
+${updateInputInterfaces.join("\n\n")}
+
+// ==================== Relationship Types ====================
+
+${withRelationsInterfaces.join("\n\n")}
+
+// ==================== LINQ Query Types ====================
+
+type Predicate<T> = (item: T) => boolean | Promise<boolean>;
+type Projection<TSource, TResult> = (item: TSource) => TResult;
+
+type WhereOperator<T> =
+    | { eq: T }
+    | { ne: T }
+    | { gt: T }
+    | { gte: T }
+    | { lt: T }
+    | { lte: T }
+    | { in: T[] }
+    | { notIn: T[] }
+    | { contains: string }
+    | { startsWith: string }
+    | { endsWith: string }
+    | { isNull: true }
+    | { isNotNull: true };
+
+type WhereClause<T> = {
+    [K in keyof T]?: T[K] | WhereOperator<T[K]> | { and: WhereClause<T>[] } | { or: WhereClause<T>[] } | { not: WhereClause<T> };
+};
+
+type OrderByClause<T> = {
+    [K in keyof T]?: "asc" | "desc";
+};
+
+// ==================== Queryable Interfaces ====================
+
+/**
+ * Async enumerable for streaming query results without loading all into memory
+ * Provides O(1) memory usage vs O(n) for ToArrayAsync and supports early termination
+ */
+declare interface IAsyncEnumerable<T> {
+    /** Async iterator for for await...of loops */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Filter items based on predicate */
+    Where(predicate: (item: T) => boolean): IAsyncEnumerable<T>;
+    /** Project items to new form */
+    Select<TResult>(selector: (item: T) => TResult): IAsyncEnumerable<TResult>;
+    /** Take first n items (supports early termination) */
+    Take(count: number): IAsyncEnumerable<T>;
+    /** Skip first n items */
+    Skip(count: number): IAsyncEnumerable<T>;
+    /** Materialize all items to array (loads entire set into memory) */
+    ToArrayAsync(): Promise<T[]>;
+    /** Get first item or throw if empty */
+    FirstAsync(): Promise<T>;
+    /** Get first item or undefined if empty */
+    FirstOrDefaultAsync(): Promise<T | undefined>;
+    /** Count items in sequence */
+    CountAsync(): Promise<number>;
+    /** Check if any item exists (short-circuits on first item) */
+    AnyAsync(): Promise<boolean>;
+}
+
+declare interface IQueryable<T> {
+    Where(where: WhereClause<T> | Predicate<T>): IQueryable<T>;
+    Select<TResult>(selector: Projection<T, TResult>): IQueryable<TResult>;
+    SelectMany<TResult>(selector: (item: T) => IQueryable<TResult> | TResult[]): IQueryable<TResult>;
+    OrderBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
+    OrderByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
+    Take(count: number): IQueryable<T>;
+    Skip(count: number): IQueryable<T>;
+    Distinct(): IQueryable<T>;
+    CountAsync(): Promise<number>;
+    CountAsync(predicate: Predicate<T>): Promise<number>;
+    AnyAsync(): Promise<boolean>;
+    AnyAsync(predicate: Predicate<T>): Promise<boolean>;
+    AllAsync(predicate: Predicate<T>): Promise<boolean>;
+    FirstAsync(): Promise<T>;
+    FirstAsync(predicate: Predicate<T>): Promise<T>;
+    FirstOrDefaultAsync(): Promise<T | undefined>;
+    FirstOrDefaultAsync(predicate: Predicate<T>): Promise<T | undefined>;
+    ToListAsync(): Promise<List<T>>;
+    ToArrayAsync(): Promise<T[]>;
+    /** Returns an async enumerable for streaming without loading all items into memory */
+    AsAsyncEnumerable(): IAsyncEnumerable<T>;
+}
+
+declare interface IOrderedQueryable<T> extends IQueryable<T> {
+    ThenBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
+    ThenByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedQueryable<T>;
+}
+
+declare interface IMutableQueryable<T, TCreateInput = Omit<T, "_id" | "_collection">> extends IQueryable<T> {
+    Where(where: WhereClause<T> | Predicate<T>): IMutableQueryable<T, TCreateInput>;
+    Select<TResult>(selector: Projection<T, TResult>): IMutableQueryable<TResult, any>;
+    Take(count: number): IMutableQueryable<T, TCreateInput>;
+    Skip(count: number): IMutableQueryable<T, TCreateInput>;
+    Distinct(): IMutableQueryable<T, TCreateInput>;
+    OrderBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
+    OrderByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
+    Insert(data: TCreateInput | Omit<T, "_id" | "_collection">): Promise<string>;
+    InsertMany(data: (TCreateInput | Omit<T, "_id" | "_collection">)[]): Promise<string[]>;
+    UpdateMany(data: Partial<Omit<T, "_id" | "_collection">>): Promise<number>;
+    DeleteMany(): Promise<number>;
+    AsNoTracking(): IQueryable<T>;
+    AsAsyncEnumerable(): IAsyncEnumerable<T>;
+}
+
+declare interface IOrderedMutableQueryable<T, TCreateInput = Omit<T, "_id" | "_collection">> extends IOrderedQueryable<T>, IMutableQueryable<T, TCreateInput> {
+    ThenBy(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
+    ThenByDescending(orderBy: OrderByClause<T> | Projection<T, any>): IOrderedMutableQueryable<T, TCreateInput>;
+}
+
+// ==================== EF Core Types ====================
+
+declare enum EntityState {
+    Detached = 0,
+    Unchanged = 1,
+    Deleted = 2,
+    Modified = 3,
+    Added = 4,
+}
+
+declare interface IEntityEntry<T> {
+    readonly entity: T;
+    readonly state: EntityState;
+    readonly originalValues: Partial<T>;
+    readonly id: string | undefined;
+    detach(): void;
+    markDeleted(): void;
+    markModified(): void;
+}
+
+declare interface IChangeTracker {
+    track<T>(collection: string, entity: T, state?: EntityState): IEntityEntry<T>;
+    getEntry<T>(collection: string, id: string | undefined, entity?: T): IEntityEntry<T> | undefined;
+    entries(state?: EntityState): IEntityEntry<unknown>[];
+    hasChanges(): boolean;
+    entriesByCollection(): Map<string, IEntityEntry<unknown>[]>;
+    acceptAllChanges(): void;
+    clear(): void;
+}
+
+declare interface IDbSet<
+    T,
+    TCreateInput = Omit<T, "_id" | "_collection">,
+    TUpdateInput = Partial<Omit<T, "_id" | "_collection">>
+> extends IMutableQueryable<T, TCreateInput> {
+    /** Track entity as Added (will INSERT on SaveChangesAsync) - accepts full entity or CreateInput */
+    Add(entity: T | TCreateInput): IEntityEntry<T>;
+    /** Track multiple entities as Added */
+    AddRange(entities: (T | TCreateInput)[]): IEntityEntry<T>[];
+    /** Mark entity for deletion (will DELETE on SaveChangesAsync) */
+    Remove(entity: T): IEntityEntry<T> | undefined;
+    /** Mark entity as Modified (will UPDATE on SaveChangesAsync) - accepts full entity or UpdateInput */
+    Update(entity: T | TUpdateInput): IEntityEntry<T> | undefined;
+    /** Immediately execute UPDATE without change tracking */
+    ExecuteUpdateAsync(update: TUpdateInput | Partial<Omit<T, "_id" | "_collection">>): Promise<number>;
+    /** Immediately execute DELETE without change tracking */
+    ExecuteDeleteAsync(): Promise<number>;
+    /** Return queryable without change tracking */
+    AsNoTracking(): IQueryable<T>;
+    /** Find entity by primary key - checks ChangeTracker cache first, then queries database */
+    FindAsync(id: string): Promise<T | undefined>;
+    /** Find entity by primary key from ChangeTracker cache only (synchronous, no DB query) */
+    Find(id: string): T | undefined;
+    /** Attach existing entity as Unchanged for selective updates */
+    Attach(entity: T): IEntityEntry<T>;
+    /** Attach multiple existing entities as Unchanged */
+    AttachRange(entities: T[]): IEntityEntry<T>[];
+    /** Returns async enumerable for streaming */
+    AsAsyncEnumerable(): IAsyncEnumerable<T>;
+}
+
+declare interface IDbContext<DataModel extends Record<string, any>> {
+    readonly ChangeTracker: IChangeTracker;
+    Set<K extends keyof DataModel & string>(collection: K): IDbSet<DataModel[K]>;
+    SaveChangesAsync(): Promise<number>;
+    /** Get EntityEntry for tracked entity using reference equality */
+    Entry<T>(entity: T): IEntityEntry<T> | undefined;
+}
+
+// ==================== linqts List<T> Class ====================
+
+declare class List<T> implements Iterable<T> {
+    constructor(items?: T[] | Iterable<T>);
+
+    // LINQ Methods
+    Where(predicate: (item: T) => boolean): List<T>;
+    Select<TResult>(selector: (item: T) => TResult): List<TResult>;
+    SelectMany<TResult>(selector: (item: T) => TResult[] | Iterable<TResult>): List<TResult>;
+    First(): T;
+    First(predicate: (item: T) => boolean): T;
+    FirstOrDefault(): T | undefined;
+    FirstOrDefault(predicate: (item: T) => boolean): T | undefined;
+    Last(): T;
+    Last(predicate: (item: T) => boolean): T;
+    LastOrDefault(): T | undefined;
+    LastOrDefault(predicate: (item: T) => boolean): T | undefined;
+    ElementAt(index: number): T;
+    ElementAtOrDefault(index: number): T | undefined;
+    Any(predicate?: (item: T) => boolean): boolean;
+    All(predicate: (item: T) => boolean): boolean;
+    Contains(item: T): boolean;
+    Count(): number;
+    Count(predicate: (item: T) => boolean): number;
+    Sum(selector?: (item: T) => number): number;
+    Average(selector?: (item: T) => number): number;
+    Min(selector?: (item: T) => number): number;
+    Max(selector?: (item: T) => number): number;
+    OrderBy(keySelector: (item: T) => any): List<T>;
+    OrderByDescending(keySelector: (item: T) => any): List<T>;
+    ThenBy(keySelector: (item: T) => any): List<T>;
+    ThenByDescending(keySelector: (item: T) => any): List<T>;
+    GroupBy<TKey>(keySelector: (item: T) => TKey): Record<string, T[]>;
+    Distinct(): List<T>;
+    Union(other: List<T>): List<T>;
+    Intersect(other: List<T>): List<T>;
+    Except(other: List<T>): List<T>;
+    Take(count: number): List<T>;
+    Skip(count: number): List<T>;
+    TakeWhile(predicate: (item: T) => boolean): List<T>;
+    SkipWhile(predicate: (item: T) => boolean): List<T>;
+    Reverse(): List<T>;
+    ToArray(): T[];
+    ToList(): List<T>;
+
+    // Mutation methods
+    Add(item: T): List<T>;
+    AddRange(items: T[]): List<T>;
+    Insert(index: number, item: T): List<T>;
+    Remove(item: T): boolean;
+    RemoveAt(index: number): void;
+    RemoveAll(predicate: (item: T) => boolean): number;
+    Clear(): void;
+
+    // Iteration
+    forEach(action: (item: T, index: number) => void): void;
+    map<TResult>(selector: (item: T, index: number) => TResult): TResult[];
+    filter(predicate: (item: T) => boolean): T[];
+    reduce<TResult>(accumulator: (acc: TResult, item: T) => TResult, initial: TResult): TResult;
+
+    // Iterator
+    [Symbol.iterator](): Iterator<T>;
+}
+
+// ==================== Repository & DbContext ====================
+
+declare interface Repository {
+    ${collectionNames.map((name) => `    ${name}: IDbSet<${capitalize(name)}Document, ${capitalize(name)}CreateInput, ${capitalize(name)}UpdateInput>;`).join("\n    ")}
+    readonly ChangeTracker: IChangeTracker;
+    SaveChangesAsync(): Promise<number>;
+}
+
+declare interface LoggerService {
+    log(data: { timestamp?: number; level: string; kind: string; message: string; context?: any }): void;
+}
+
+declare interface ScriptContext {
+    repository: Repository & IDbContext<any>;
+    List: typeof List;
+    logger: LoggerService;
+    collections: string[];
+}
+
+// Global declarations for the Action Editor
+declare const repository: Repository;
+declare const List: typeof List;
+declare const logger: LoggerService;
+declare const collections: string[];
+declare const ctx: ScriptContext;
 `;
         return {
             collections: collectionNames,