@archlast/server 0.0.1

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

@@ -0,0 +1,734 @@
+"use strict";
+/**
+ * Admin Data Service
+ *
+ * Business logic for admin data operations extracted from HTTP controllers.
+ * Handles document CRUD, script execution, and type definitions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminDataError = void 0;
+exports.createAdminDataService = createAdminDataService;
+const interfaces_js_1 = require("../../auth/interfaces.js");
+const factory_js_1 = require("../../repository/factory.js");
+const index_js_1 = require("../../linq/index.js");
+const logger_js_1 = require("../../logging/logger.js");
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_SCRIPT_TIMEOUT = 30000;
+const MAX_SCRIPT_TIMEOUT = 60000;
+// ============================================================================
+// Errors
+// ============================================================================
+class AdminDataError extends Error {
+    statusCode;
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "AdminDataError";
+    }
+}
+exports.AdminDataError = AdminDataError;
+// ============================================================================
+// Service Factory
+// ============================================================================
+function createAdminDataService() {
+    /**
+     * Get admin auth helper for running mutations
+     */
+    function getAdminAuth() {
+        return (0, interfaces_js_1.attachAuthHelpers)({
+            type: "session",
+            userId: "admin",
+            isAuthenticated: true,
+            isAdminToken: false,
+            provider: "archlast",
+            raw: null,
+            user: { _id: "admin", name: "Admin" },
+            session: null,
+            apiKeyId: null,
+            apiKey: null,
+            tenant: null,
+            membership: null,
+            tenantId: null,
+            role: "admin",
+            permissions: ["*"],
+        });
+    }
+    /**
+     * List all collections with counts
+     */
+    async function listCollections(options) {
+        const { db, deploymentHandler } = options;
+        const schema = deploymentHandler.getSchema();
+        const collections = [];
+        if (schema?.tables) {
+            for (const name of Object.keys(schema.tables)) {
+                const count = await db.count(name);
+                collections.push({ name, count });
+            }
+        }
+        return collections;
+    }
+    /**
+     * List documents in a collection
+     */
+    async function listDocuments(options) {
+        const { db, collection, limit, offset, sort, filter } = options;
+        // Parse sort parameter (format: "field:direction" or "field" for asc)
+        let sortField = undefined;
+        let sortDirection = "asc";
+        if (sort) {
+            const parts = sort.split(":");
+            sortField = parts[0];
+            if (parts[1] === "desc") {
+                sortDirection = "desc";
+            }
+        }
+        // Basic filter support
+        let where = undefined;
+        if (filter) {
+            try {
+                where = JSON.parse(filter);
+            }
+            catch {
+                // ignore invalid filter
+            }
+        }
+        let query = db.query(collection);
+        if (where)
+            query = query.where(where);
+        // Apply sorting before pagination
+        if (sortField) {
+            query = query.orderBy({ [sortField]: sortDirection });
+        }
+        const documents = await query.take(limit).skip(offset).findMany();
+        let countQuery = db.query(collection);
+        if (where)
+            countQuery = countQuery.where(where);
+        const total = await countQuery.count();
+        return { documents, total, limit, offset };
+    }
+    /**
+     * Create a new document
+     */
+    async function createDocument(options) {
+        const { engine, wsHandler, collection, data } = options;
+        const adminAuth = getAdminAuth();
+        const { result, affectedQueries } = await engine.runMutation("sys.createDocument", { collection, data }, adminAuth);
+        if (affectedQueries.size > 0) {
+            void wsHandler.revalidateQueries(affectedQueries);
+        }
+        return result;
+    }
+    /**
+     * Update a document
+     */
+    async function updateDocument(options) {
+        const { engine, wsHandler, collection, id, data } = options;
+        const adminAuth = getAdminAuth();
+        const { result, affectedQueries } = await engine.runMutation("sys.updateDocument", { collection, id, data }, adminAuth);
+        void wsHandler.revalidateQueries(affectedQueries);
+        return result;
+    }
+    /**
+     * Delete a document
+     */
+    async function deleteDocument(options) {
+        const { engine, wsHandler, collection, id } = options;
+        const adminAuth = getAdminAuth();
+        const { result, affectedQueries } = await engine.runMutation("sys.deleteDocument", { collection, id }, adminAuth);
+        if (affectedQueries.size > 0) {
+            void wsHandler.revalidateQueries(affectedQueries);
+        }
+        return result;
+    }
+    /**
+     * Bulk delete documents
+     */
+    async function bulkDeleteDocuments(options) {
+        const { engine, wsHandler, collection, ids } = options;
+        const adminAuth = getAdminAuth();
+        const allAffectedQueries = new Set();
+        let deletedCount = 0;
+        for (const id of ids) {
+            try {
+                const { affectedQueries } = await engine.runMutation("sys.deleteDocument", { collection, id }, adminAuth);
+                affectedQueries.forEach((q) => allAffectedQueries.add(q));
+                deletedCount++;
+            }
+            catch (e) {
+                // Continue with other documents even if one fails
+                console.error(`Failed to delete document ${id}:`, e);
+            }
+        }
+        // Revalidate all affected queries
+        if (allAffectedQueries.size > 0) {
+            void wsHandler.revalidateQueries(allAffectedQueries);
+        }
+        return { deletedCount };
+    }
+    /**
+     * Execute admin script
+     */
+    async function executeScript(options) {
+        const { db, deploymentHandler, wsHandler, code, timeout } = options;
+        // Set timeout limits
+        const scriptTimeout = Math.min(Math.max(timeout ?? DEFAULT_SCRIPT_TIMEOUT, 1000), MAX_SCRIPT_TIMEOUT);
+        // Create async function with timeout
+        const executeWithTimeout = async () => {
+            try {
+                // Get schema and create repository
+                const schema = deploymentHandler.getSchema();
+                const collectionNames = schema?.tables ? Object.keys(schema.tables) : [];
+                // Create a wrapper function that creates DbSet with proper dependencies
+                const createDbSetWrapper = (collection, changeTracker) => {
+                    const { QueryProvider } = require("../../repository/provider.js");
+                    const { MutableQueryable } = require("../../repository/queryable.js");
+                    const collectionName = String(collection);
+                    const provider = new QueryProvider(db, collectionName);
+                    const sourceExpr = { kind: "Source", mutable: true };
+                    const baseQueryable = new MutableQueryable(provider, sourceExpr, db, collectionName);
+                    return (0, factory_js_1.createDbSet)(db, collectionName, changeTracker, provider, sourceExpr, baseQueryable);
+                };
+                // Create DbContext for EF Core-style change tracking
+                const repository = (0, factory_js_1.createDbContext)(db, createDbSetWrapper, new factory_js_1.ChangeTracker());
+                // Create the script context object with repository, List, and other utilities
+                const scriptCtx = {
+                    // LINQ-style repository with EF Core change tracking
+                    repository,
+                    // linqts List class for in-memory LINQ operations
+                    List: index_js_1.List,
+                    // Logger service
+                    logger: {
+                        log: (data) => logger_js_1.logger.log(data),
+                    },
+                    // Collection names array (for reference)
+                    collections: collectionNames,
+                };
+                // 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) };
+                        }
+                        `);
+                // Create a safe console proxy
+                const logs = [];
+                const safeConsole = {
+                    log: (...args) => logs.push(args
+                        .map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+                        .join(" ")),
+                    error: (...args) => logs.push("[ERROR] " +
+                        args
+                            .map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+                            .join(" ")),
+                    warn: (...args) => logs.push("[WARN] " +
+                        args
+                            .map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+                            .join(" ")),
+                    info: (...args) => logs.push("[INFO] " +
+                        args
+                            .map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+                            .join(" ")),
+                };
+                // Execute the script with timeout
+                const startTime = Date.now();
+                const resultPromise = scriptFn(scriptCtx, safeConsole);
+                // Add timeout wrapper
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Script execution timed out after ${scriptTimeout}ms`)), scriptTimeout));
+                const result = await Promise.race([resultPromise, timeoutPromise]);
+                const executionTime = Date.now() - startTime;
+                // Trigger WebSocket reactivity for all collections
+                if (wsHandler && collectionNames.length > 0) {
+                    for (const collection of collectionNames) {
+                        try {
+                            if (typeof wsHandler.broadcastAdminEvent === "function") {
+                                wsHandler.broadcastAdminEvent("admin:data:invalidated", {
+                                    collection,
+                                    action: "update",
+                                });
+                            }
+                        }
+                        catch {
+                            // Ignore broadcast errors
+                        }
+                    }
+                }
+                return {
+                    result,
+                    logs,
+                    executionTime,
+                    affectedCollections: collectionNames,
+                };
+            }
+            catch (error) {
+                return {
+                    error: error instanceof Error ? error.message : String(error),
+                    result: null,
+                    logs: [],
+                    executionTime: 0,
+                    affectedCollections: [],
+                };
+            }
+        };
+        return await executeWithTimeout();
+    }
+    /**
+     * Get script type definitions
+     */
+    function getScriptTypes(options) {
+        const { deploymentHandler } = options;
+        const runtimeSchema = deploymentHandler.getSchema?.();
+        const tables = runtimeSchema?.tables ?? {};
+        const collectionNames = Object.keys(tables);
+        // Helper function to get the unwrapped zod type
+        function getZodType(fieldSchema) {
+            let zod = fieldSchema?.zodSchema;
+            const meta = fieldSchema?.metadata ?? {};
+            if (!zod && fieldSchema?._def) {
+                zod = fieldSchema;
+            }
+            let isOptional = Boolean(meta.nullable);
+            let unwrappedZod = zod;
+            if (zod?._def) {
+                while (unwrappedZod?._def) {
+                    const defType = unwrappedZod._def.type;
+                    if (defType === "default") {
+                        unwrappedZod = unwrappedZod._def.innerType;
+                    }
+                    else if (defType === "optional" || defType === "nullable") {
+                        isOptional = true;
+                        unwrappedZod = unwrappedZod._def.innerType;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+            const baseType = unwrappedZod?._def?.type ?? "unknown";
+            // Primary key fields named _id are ID type
+            if (meta.primaryKey) {
+                return { type: "string", isOptional };
+            }
+            // Foreign key fields (ending with _id) are ID type
+            if (meta.foreignKey) {
+                return { type: "string", isOptional };
+            }
+            // Type mapping from zod to TypeScript
+            const typeMap = {
+                string: "string",
+                number: "number",
+                boolean: "boolean",
+                any: "any",
+                date: "Date",
+                array: "any[]",
+                object: "Record<string, any>",
+            };
+            return { type: typeMap[baseType] || "any", isOptional };
+        }
+        // Check if a field has auto-generated modifier
+        function hasAutoGeneratedModifier(fieldSchema) {
+            const meta = fieldSchema?.metadata ?? {};
+            // AutoGenerated flag is 1 << 2 = 4
+            return (meta.modifiers & 4) === 4;
+        }
+        // Check if a field has createdNow modifier
+        function hasCreatedNowModifier(fieldSchema) {
+            const meta = fieldSchema?.metadata ?? {};
+            // CreatedNow flag is 1 << 0 = 1
+            return (meta.modifiers & 1) === 1;
+        }
+        // Check if a field has updateNow modifier
+        function hasUpdateNowModifier(fieldSchema) {
+            const meta = fieldSchema?.metadata ?? {};
+            // UpdateNow flag is 1 << 1 = 2
+            return (meta.modifiers & 2) === 2;
+        }
+        // Generate TypeScript interfaces for each collection
+        function generateCollectionInterface(name, tableDef) {
+            const schemaFields = tableDef?.schema ?? {};
+            const fields = [];
+            for (const [fieldName, fieldSchema] of Object.entries(schemaFields)) {
+                const { type, isOptional } = getZodType(fieldSchema);
+                const optional = isOptional || fieldName === "updatedAt" ? "?" : "";
+                fields.push(`    ${fieldName}${optional}: ${type};`);
+            }
+            // Always include _collection field
+            fields.push(`    _collection: "${name}";`);
+            return `declare interface ${capitalize(name)}Document {\n${fields.join("\n")}\n}`;
+        }
+        // Generate CreateInput interface (excludes auto-generated fields)
+        function generateCreateInputInterface(name, tableDef) {
+            const schemaFields = tableDef?.schema ?? {};
+            const fields = [];
+            for (const [fieldName, fieldSchema] of Object.entries(schemaFields)) {
+                // Skip system fields
+                if (fieldName === "_id" || fieldName === "_collection")
+                    continue;
+                // Skip auto-generated fields
+                if (hasAutoGeneratedModifier(fieldSchema))
+                    continue;
+                // Skip createdNow fields (auto-generated on insert)
+                if (hasCreatedNowModifier(fieldSchema))
+                    continue;
+                const { type } = getZodType(fieldSchema);
+                fields.push(`    ${fieldName}?: ${type};`);
+            }
+            return `declare interface ${capitalize(name)}CreateInput {\n${fields.join("\n")}\n}`;
+        }
+        // Generate UpdateInput interface (excludes read-only fields)
+        function generateUpdateInputInterface(name, tableDef) {
+            const schemaFields = tableDef?.schema ?? {};
+            const fields = [];
+            for (const [fieldName, fieldSchema] of Object.entries(schemaFields)) {
+                // Skip system fields
+                if (fieldName === "_id" || fieldName === "_collection")
+                    continue;
+                // Skip auto-generated fields
+                if (hasAutoGeneratedModifier(fieldSchema))
+                    continue;
+                // Skip createdNow fields (not updatable)
+                if (hasCreatedNowModifier(fieldSchema))
+                    continue;
+                const { type } = getZodType(fieldSchema);
+                fields.push(`    ${fieldName}?: ${type};`);
+            }
+            return `declare interface ${capitalize(name)}UpdateInput {\n${fields.join("\n")}\n}`;
+        }
+        // Generate WithRelations interface for loaded relationships
+        function generateWithRelationsInterface(name, tableDef, allTables) {
+            const relationships = tableDef?.relationships ?? {};
+            const relationFields = [];
+            for (const [relationName, relationDef] of Object.entries(relationships)) {
+                const def = relationDef;
+                if (def.type === "hasMany") {
+                    const relatedTypeName = capitalize(def.table ?? relationName);
+                    relationFields.push(`    ${relationName}?: ${relatedTypeName}Document[];`);
+                }
+                else if (def.type === "belongsTo") {
+                    const relatedTypeName = capitalize(def.table ?? relationName);
+                    relationFields.push(`    ${relationName}?: ${relatedTypeName}Document;`);
+                }
+            }
+            if (relationFields.length === 0) {
+                return `declare type ${capitalize(name)}WithRelations = ${capitalize(name)}Document;`;
+            }
+            return `declare interface ${capitalize(name)}WithRelations extends ${capitalize(name)}Document {\n${relationFields.join("\n")}\n}`;
+        }
+        function capitalize(str) {
+            return str.charAt(0).toUpperCase() + str.slice(1);
+        }
+        // Generate document type interfaces
+        const documentInterfaces = [];
+        const createInputInterfaces = [];
+        const updateInputInterfaces = [];
+        const withRelationsInterfaces = [];
+        for (const [name, tableDef] of Object.entries(tables)) {
+            documentInterfaces.push(generateCollectionInterface(name, tableDef));
+            createInputInterfaces.push(generateCreateInputInterface(name, tableDef));
+            updateInputInterfaces.push(generateUpdateInputInterface(name, tableDef));
+            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;
+`;
+        return {
+            collections: collectionNames,
+            typeDefinitions,
+            monacoLibs: {},
+        };
+    }
+    return {
+        listCollections,
+        listDocuments,
+        createDocument,
+        updateDocument,
+        deleteDocument,
+        bulkDeleteDocuments,
+        executeScript,
+        getScriptTypes,
+    };
+}
+//# sourceMappingURL=data.service.js.map