@cedarjs/gqlorm 2.6.1-next.104

package/dist/live/types.d.ts

@@ -0,0 +1,262 @@
+/**
+ * Type definitions for live query functionality
+ * Defines interfaces and types for real-time GraphQL queries with @live directive
+ */
+import { type ModelSchema } from '../types/schema.js';
+export interface LiveQueryOptions {
+    /**
+     * Whether to automatically reconnect on connection loss
+     * @default true
+     */
+    autoReconnect?: boolean;
+    /**
+     * Maximum number of reconnection attempts
+     * @default 5
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Delay between reconnection attempts in milliseconds
+     * @default 1000
+     */
+    reconnectDelay?: number;
+    /**
+     * Whether to use exponential backoff for reconnection delays
+     * @default true
+     */
+    exponentialBackoff?: boolean;
+    /**
+     * Maximum delay between reconnection attempts in milliseconds
+     * @default 30000
+     */
+    maxReconnectDelay?: number;
+    /**
+     * Custom headers to send with live query requests
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom authentication token
+     */
+    authToken?: string;
+    /**
+     * WebSocket URL for live query subscriptions
+     */
+    websocketUrl?: string;
+    /**
+     * Whether to enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Whether to resubscribe to queries upon reconnection
+     * @default true
+     */
+    refetchOnReconnect?: boolean;
+}
+export type ResolvedLiveQueryOptions = Required<Omit<LiveQueryOptions, 'authToken' | 'websocketUrl'>> & {
+    authToken: string | undefined;
+    websocketUrl: string | undefined;
+};
+export type LiveQueryConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'error' | 'closed';
+export type LiveQueryUpdateType = 'insert' | 'update' | 'delete' | 'refresh';
+export interface LiveQueryUpdate<T = any> {
+    /**
+     * Type of update that occurred
+     */
+    type: LiveQueryUpdateType;
+    /**
+     * Updated data (for insert/update) or deleted item (for delete)
+     */
+    data?: T;
+    /**
+     * Complete updated result set (for refresh)
+     */
+    result?: T;
+    /**
+     * Timestamp when the update occurred
+     */
+    timestamp: Date;
+    /**
+     * Optional metadata about the update
+     */
+    metadata?: Record<string, any>;
+}
+export interface LiveQueryError {
+    /**
+     * Error code
+     */
+    code: string;
+    /**
+     * Human-readable error message
+     */
+    message: string;
+    /**
+     * Optional error details
+     */
+    details?: any;
+    /**
+     * Timestamp when the error occurred
+     */
+    timestamp: Date;
+}
+export interface LiveQuerySubscription<T = any> {
+    /**
+     * Unique identifier for this subscription
+     */
+    id: string;
+    /**
+     * GraphQL query string
+     */
+    query: string;
+    /**
+     * Query variables
+     */
+    variables?: Record<string, any>;
+    /**
+     * Current connection state
+     */
+    connectionState: LiveQueryConnectionState;
+    /**
+     * Latest query result
+     */
+    data: T | undefined;
+    /**
+     * Latest error, if any
+     */
+    error: LiveQueryError | undefined;
+    /**
+     * Whether the subscription is currently loading
+     */
+    loading: boolean;
+    /**
+     * Unsubscribe from live updates
+     */
+    unsubscribe: () => void;
+    /**
+     * Manually refetch the query
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Register a callback for live data updates
+     * Returns a function to unregister the callback
+     */
+    onUpdate: (callback: (update: LiveQueryUpdate) => void) => () => void;
+}
+export interface LiveQueryClientConfig extends LiveQueryOptions {
+    /**
+     * GraphQL endpoint URL
+     */
+    endpoint: string;
+    /**
+     * WebSocket endpoint URL (optional, will derive from endpoint if not provided)
+     */
+    websocketUrl?: string;
+    /**
+     * Model schema defining scalar fields for each model
+     */
+    schema?: ModelSchema;
+}
+export interface LiveQueryTransport {
+    /**
+     * Connect to the live query service
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the live query service
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Subscribe to a live query
+     */
+    subscribe<T>(query: string, variables?: Record<string, any>, options?: LiveQueryOptions): LiveQuerySubscription<T>;
+    /**
+     * Get current connection state
+     */
+    getConnectionState(): LiveQueryConnectionState;
+    /**
+     * Add connection state change listener
+     */
+    onConnectionStateChange(listener: (state: LiveQueryConnectionState) => void): () => void;
+    /**
+     * Add error listener
+     */
+    onError(listener: (error: LiveQueryError) => void): () => void;
+}
+export interface LiveQueryCache {
+    /**
+     * Get cached result for a query
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Set cached result for a query
+     */
+    set<T>(key: string, data: T): void;
+    /**
+     * Remove cached result
+     */
+    remove(key: string): void;
+    /**
+     * Clear all cached results
+     */
+    clear(): void;
+    /**
+     * Get cache key for a query
+     */
+    getKey(query: string, variables?: Record<string, any>): string;
+}
+export interface LiveQueryContextValue {
+    /**
+     * Live query transport instance
+     */
+    transport?: LiveQueryTransport;
+    /**
+     * Live query cache instance
+     */
+    cache?: LiveQueryCache;
+    /**
+     * Global live query options
+     */
+    options?: LiveQueryOptions;
+    /**
+     * Model schema defining scalar fields for each model
+     */
+    schema?: ModelSchema;
+    /**
+     * Query builder instance with schema
+     */
+    queryBuilder?: any;
+    /**
+     * Whether the client is connected
+     */
+    isConnected: boolean;
+    /**
+     * Current connection state
+     */
+    connectionState: LiveQueryConnectionState;
+}
+export interface LiveQueryHookResult<T = any> {
+    /**
+     * Query result data
+     */
+    data: T | undefined;
+    /**
+     * Loading state
+     */
+    loading: boolean;
+    /**
+     * Error state
+     */
+    error: LiveQueryError | undefined;
+    /**
+     * Connection state
+     */
+    connectionState: LiveQueryConnectionState;
+    /**
+     * Refetch function
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Subscription instance (for advanced usage)
+     */
+    subscription: LiveQuerySubscription<T> | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/live/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/live/types.ts"],"names":[],"mappings":"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"}

package/dist/parser/queryParser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Query parser that converts ORM-style queries to AST representation
+ * Handles parsing of Prisma-like query syntax into our internal AST format
+ */
+import type { QueryAST, QueryOperation } from '../types/ast.js';
+import type { FindFirstArgs, FindManyArgs, FindUniqueArgs } from '../types/orm.js';
+export declare class QueryParseError extends Error {
+    context?: any | undefined;
+    constructor(message: string, context?: any | undefined);
+}
+export declare class QueryParser {
+    #private;
+    /**
+     * Parse a complete query from model, operation, and arguments
+     */
+    parseQuery(model: string, operation: QueryOperation, args?: FindManyArgs<any> | FindUniqueArgs<any> | FindFirstArgs<any>): QueryAST;
+    /**
+     * Parse comparison operator string
+     */
+    private parseComparisonOperator;
+    /**
+     * Validate AST structure
+     */
+    validateAST(ast: QueryAST): void;
+}
+export declare const queryParser: QueryParser;
+//# sourceMappingURL=queryParser.d.ts.map

package/dist/parser/queryParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryParser.d.ts","sourceRoot":"","sources":["../../src/parser/queryParser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAUV,QAAQ,EACR,cAAc,EAMf,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EAKf,MAAM,iBAAiB,CAAA;AAGxB,qBAAa,eAAgB,SAAQ,KAAK;IAG/B,OAAO,CAAC,EAAE,GAAG;gBADpB,OAAO,EAAE,MAAM,EACR,OAAO,CAAC,EAAE,GAAG,YAAA;CAKvB;AAED,qBAAa,WAAW;;IACtB;;OAEG;IACH,UAAU,CACR,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,cAAc,EACzB,IAAI,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,GAClE,QAAQ;IAoNX;;OAEG;IACH,OAAO,CAAC,uBAAuB;IA2I/B;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;CAmBjC;AAGD,eAAO,MAAM,WAAW,aAAoB,CAAA"}

package/dist/parser/queryParser.js

@@ -0,0 +1,312 @@
+import { isLogicalOperator } from "../types/typeUtils.js";
+class QueryParseError extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "QueryParseError";
+  }
+}
+class QueryParser {
+  /**
+   * Parse a complete query from model, operation, and arguments
+   */
+  parseQuery(model, operation, args) {
+    if (!model || !operation) {
+      throw new QueryParseError("Model and operation are required");
+    }
+    const query = {
+      type: "Query",
+      model,
+      operation
+    };
+    if (args && Object.keys(args).length > 0) {
+      query.args = this.#parseQueryArgs(args);
+    }
+    return query;
+  }
+  /**
+   * Parse query arguments into AST
+   */
+  #parseQueryArgs(args) {
+    const queryArgs = {
+      type: "QueryArgs"
+    };
+    if (args.where) {
+      queryArgs.where = this.#parseWhere(args.where);
+    }
+    if (args.select) {
+      queryArgs.select = this.#parseSelect(args.select);
+    }
+    if (args.include) {
+      queryArgs.include = this.#parseInclude(args.include);
+    }
+    if (args.orderBy) {
+      queryArgs.orderBy = this.#parseOrderBy(args.orderBy);
+    }
+    if (typeof args.take === "number") {
+      queryArgs.take = args.take;
+    }
+    if (typeof args.skip === "number") {
+      queryArgs.skip = args.skip;
+    }
+    return queryArgs;
+  }
+  /**
+   * Parse WHERE clause into AST
+   */
+  #parseWhere(where) {
+    const conditions = this.#parseWhereConditions(where);
+    return {
+      type: "Where",
+      conditions
+    };
+  }
+  /**
+   * Parse where conditions recursively
+   */
+  // TODO: See if we can type `where` to `Record<any, any>`
+  #parseWhereConditions(where) {
+    const conditions = Object.entries(where).map(([key, value]) => {
+      if (isLogicalOperator(key)) {
+        return this.#parseLogicalCondition(key, value);
+      }
+      if (this.#isRelationCondition(value)) {
+        return this.#parseRelationCondition(key, value);
+      }
+      return this.#parseFieldCondition(key, value);
+    });
+    return conditions;
+  }
+  /**
+   * Parse logical condition (AND, OR, NOT)
+   */
+  #parseLogicalCondition(operator, value) {
+    let nestedConditions = [];
+    if (operator === "NOT") {
+      nestedConditions = this.#parseWhereConditions(value);
+    } else {
+      if (Array.isArray(value)) {
+        for (const condition of value) {
+          nestedConditions.push(...this.#parseWhereConditions(condition));
+        }
+      } else {
+        throw new QueryParseError(`${operator} operator expects an array`, {
+          operator,
+          value
+        });
+      }
+    }
+    return {
+      type: "LogicalCondition",
+      operator,
+      conditions: nestedConditions
+    };
+  }
+  /**
+   * Check if a value represents a relation condition
+   */
+  #isRelationCondition(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && !this.#isFilterObject(value) && !(value instanceof Date);
+  }
+  /**
+   * Parse relation condition
+   */
+  #parseRelationCondition(field, value) {
+    const nestedConditions = this.#parseWhereConditions(value);
+    return {
+      type: "RelationCondition",
+      relation: field,
+      condition: {
+        type: "Where",
+        conditions: nestedConditions
+      }
+    };
+  }
+  /**
+   * Check if value represents a filter object
+   */
+  #isFilterObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const filterOperators = /* @__PURE__ */ new Set([
+      "equals",
+      "not",
+      "in",
+      "notIn",
+      "lt",
+      "lte",
+      "gt",
+      "gte",
+      "contains",
+      "startsWith",
+      "endsWith",
+      "isNull",
+      "isNotNull"
+    ]);
+    return Object.keys(value).some((key) => filterOperators.has(key));
+  }
+  /**
+   * Parse field condition
+   */
+  #parseFieldCondition(field, value) {
+    if (!this.#isFilterObject(value)) {
+      return {
+        type: "FieldCondition",
+        field,
+        operator: "equals",
+        value
+      };
+    }
+    const filterEntries = Object.entries(value);
+    if (filterEntries.length !== 1) {
+      throw new QueryParseError(
+        `Field condition must have exactly one operator`,
+        { field, value }
+      );
+    }
+    const [operatorStr, operatorValue] = filterEntries[0];
+    const operator = this.parseComparisonOperator(operatorStr);
+    return {
+      type: "FieldCondition",
+      field,
+      operator,
+      value: operatorValue
+    };
+  }
+  /**
+   * Parse comparison operator string
+   */
+  parseComparisonOperator(operator) {
+    const validOperators = [
+      "equals",
+      "not",
+      "in",
+      "notIn",
+      "lt",
+      "lte",
+      "gt",
+      "gte",
+      "contains",
+      "startsWith",
+      "endsWith",
+      "isNull",
+      "isNotNull"
+    ];
+    if (!validOperators.includes(operator)) {
+      throw new QueryParseError(`Invalid comparison operator: ${operator}`);
+    }
+    return operator;
+  }
+  /**
+   * Parse SELECT clause into AST
+   */
+  #parseSelect(select) {
+    const fields = [];
+    for (const [field, selected] of Object.entries(select)) {
+      if (typeof selected === "boolean") {
+        fields.push({
+          type: "FieldSelection",
+          field,
+          selected
+        });
+      } else if (typeof selected === "object" && selected !== null) {
+        const selectedObj = selected;
+        const fieldSelection = {
+          type: "FieldSelection",
+          field,
+          selected: true
+        };
+        if (selectedObj.select) {
+          fieldSelection.nested = this.#parseSelect(selectedObj.select);
+        } else if (selectedObj.include) {
+          fieldSelection.nested = this.#parseInclude(selectedObj.include);
+        }
+        fields.push(fieldSelection);
+      }
+    }
+    return {
+      type: "Select",
+      fields
+    };
+  }
+  /**
+   * Parse INCLUDE clause into AST
+   */
+  #parseInclude(include) {
+    const relations = [];
+    for (const [relation, inclusion] of Object.entries(include)) {
+      if (typeof inclusion === "boolean") {
+        relations.push({
+          type: "RelationInclusion",
+          relation,
+          included: inclusion
+        });
+      } else if (typeof inclusion === "object" && inclusion !== null) {
+        const relationInclusion = {
+          type: "RelationInclusion",
+          relation,
+          included: true
+        };
+        if (inclusion.include) {
+          relationInclusion.nested = this.#parseInclude(inclusion.include);
+        }
+        if (inclusion.select || inclusion.where || inclusion.orderBy || inclusion.take || inclusion.skip) {
+          relationInclusion.args = this.#parseQueryArgs(inclusion);
+        }
+        relations.push(relationInclusion);
+      }
+    }
+    return {
+      type: "Include",
+      relations
+    };
+  }
+  /**
+   * Parse ORDER BY clause
+   */
+  #parseOrderBy(orderBy) {
+    const fields = [];
+    const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+    for (const orderByItem of orderByArray) {
+      for (const [field, direction] of Object.entries(orderByItem)) {
+        if (direction === "asc" || direction === "desc") {
+          fields.push({
+            type: "OrderByField",
+            field,
+            direction
+          });
+        } else {
+          throw new QueryParseError(
+            `Invalid sort direction: ${direction}. Must be 'asc' or 'desc'`
+          );
+        }
+      }
+    }
+    return {
+      type: "OrderBy",
+      fields
+    };
+  }
+  /**
+   * Validate AST structure
+   */
+  validateAST(ast) {
+    if (!ast.model || !ast.operation) {
+      throw new QueryParseError("Invalid AST: missing model or operation");
+    }
+    if (ast.operation === "findUnique" || ast.operation === "findUniqueOrThrow") {
+      if (!ast.args?.where) {
+        throw new QueryParseError(
+          "findUnique operations require a where clause"
+        );
+      }
+    }
+  }
+}
+const queryParser = new QueryParser();
+export {
+  QueryParseError,
+  QueryParser,
+  queryParser
+};