@microsoft/rayfin-data 1.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @microsoft/rayfin-data
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which
+includes all source code repositories in our GitHub organizations.
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+For security reporting information, locations, contact information, and policies,
+please review the latest guidance for Microsoft repositories at
+[https://aka.ms/SECURITY.md](https://aka.ms/SECURITY.md).
+
+## Trademarks
+
+This project may contain trademarks or logos for projects, products, or services.
+Authorized use of Microsoft trademarks or logos must follow the [Microsoft Trademark and Brand Guidelines](https://www.microsoft.com/legal/intellectualproperty/trademarks/usage/general).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+Any use of third-party trademarks or logos is subject to those third parties' policies.
+
+## License
+
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client/DataApi.d.ts

@@ -0,0 +1,64 @@
+import type { ApiClient as ApiClientType } from '@microsoft/rayfin-lib';
+import { GraphQLEntityClient } from '../graphql/GraphQLEntityClient';
+import type { EntitySchema } from '../graphql/types';
+/**
+ * Type-safe data clients based on entity schema.
+ */
+export type TypedDataClients<TSchema extends EntitySchema> = {
+    [K in keyof TSchema]: GraphQLEntityClient<TSchema, K>;
+};
+/**
+ * Data-specific operations client for interacting with Data API Builder GraphQL endpoints.
+ *
+ * Use the `createDataApi` factory function to create instances instead of instantiating directly.
+ *
+ * @template TSchema - Object type mapping entity names to their types
+ */
+export declare class DataApi<TSchema extends EntitySchema = Record<string, any>> {
+    private apiClient;
+    private clientCache;
+    constructor(apiClient: ApiClientType);
+    /**
+     * Get a GraphQL client for a specific entity.
+     */
+    getClient<K extends keyof TSchema>(entityName: K): GraphQLEntityClient<TSchema, K>;
+    /**
+     * Get all available entity names.
+     * In a Proxy-based client, this returns all entity names that have been accessed.
+     */
+    getEntityNames(): (keyof TSchema)[];
+    /**
+     * Create a Proxy that generates GraphQL clients on-demand.
+     */
+    private createProxy;
+}
+/**
+ * Create a type-safe DataApi instance for interacting with Data API Builder GraphQL endpoints.
+ *
+ * @template TSchema - Object type mapping entity names to their types
+ * @param apiClient - The ApiClient instance for making HTTP requests
+ * @returns A fully typed DataApi instance with direct entity access
+ *
+ * @example
+ * ```typescript
+ * const dataApi = createDataApi<{
+ *   User: User;
+ *   Organization: Organization;
+ * }>(apiClient);
+ *
+ * // GraphQL fluent interface (direct entity access):
+ * const activeUsers = await dataApi.User
+ *   .select(['id', 'name', 'email'])
+ *   .where({ isActive: { eq: true } })
+ *   .orderBy({ createdAt: 'desc' })
+ *   .execute();
+ *
+ * // GraphQL mutations:
+ * const newUser = await dataApi.User.create({
+ *   email: 'user@example.com',
+ *   name: 'Jane Doe'
+ * });
+ * ```
+ */
+export declare function createDataApi<TSchema extends EntitySchema>(apiClient: ApiClientType): DataApi<TSchema> & TypedDataClients<TSchema>;
+//# sourceMappingURL=DataApi.d.ts.map

package/dist/client/DataApi.js

@@ -0,0 +1,109 @@
+import { GraphQLClient } from '../graphql/GraphQLClient';
+import { GraphQLEntityClient } from '../graphql/GraphQLEntityClient';
+/**
+ * Data-specific operations client for interacting with Data API Builder GraphQL endpoints.
+ *
+ * Use the `createDataApi` factory function to create instances instead of instantiating directly.
+ *
+ * @template TSchema - Object type mapping entity names to their types
+ */
+export class DataApi {
+    apiClient;
+    clientCache = new Map();
+    // Single constructor - requires ApiClient injection
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        // Return a Proxy that generates GraphQL clients on-demand
+        return this.createProxy();
+    }
+    /**
+     * Get a GraphQL client for a specific entity.
+     */
+    getClient(entityName) {
+        const name = String(entityName);
+        if (!this.clientCache.has(name)) {
+            const graphqlClient = new GraphQLClient(this.apiClient, `/graphql`);
+            this.clientCache.set(name, new GraphQLEntityClient(graphqlClient, entityName));
+        }
+        return this.clientCache.get(name);
+    }
+    /**
+     * Get all available entity names.
+     * In a Proxy-based client, this returns all entity names that have been accessed.
+     */
+    getEntityNames() {
+        return Array.from(this.clientCache.keys());
+    }
+    /**
+     * Create a Proxy that generates GraphQL clients on-demand.
+     */
+    createProxy() {
+        return new Proxy(this, {
+            get: (target, prop) => {
+                // Allow access to class methods and properties
+                if (prop in target) {
+                    return target[prop];
+                }
+                // Generate entity client for string properties
+                if (typeof prop === 'string') {
+                    return this.getClient(prop);
+                }
+                return undefined;
+            },
+            ownKeys: () => {
+                // Return only entity names for Object.keys() etc.
+                return Array.from(this.clientCache.keys());
+            },
+            has: (target, prop) => {
+                // Check class properties first
+                if (prop in target) {
+                    return true;
+                }
+                // Always return true for string properties (entity names)
+                return typeof prop === 'string';
+            },
+            getOwnPropertyDescriptor: (target, prop) => {
+                if (typeof prop === 'string') {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: this.getClient(prop),
+                    };
+                }
+                return undefined;
+            },
+        });
+    }
+}
+/**
+ * Create a type-safe DataApi instance for interacting with Data API Builder GraphQL endpoints.
+ *
+ * @template TSchema - Object type mapping entity names to their types
+ * @param apiClient - The ApiClient instance for making HTTP requests
+ * @returns A fully typed DataApi instance with direct entity access
+ *
+ * @example
+ * ```typescript
+ * const dataApi = createDataApi<{
+ *   User: User;
+ *   Organization: Organization;
+ * }>(apiClient);
+ *
+ * // GraphQL fluent interface (direct entity access):
+ * const activeUsers = await dataApi.User
+ *   .select(['id', 'name', 'email'])
+ *   .where({ isActive: { eq: true } })
+ *   .orderBy({ createdAt: 'desc' })
+ *   .execute();
+ *
+ * // GraphQL mutations:
+ * const newUser = await dataApi.User.create({
+ *   email: 'user@example.com',
+ *   name: 'Jane Doe'
+ * });
+ * ```
+ */
+export function createDataApi(apiClient) {
+    return new DataApi(apiClient);
+}
+//# sourceMappingURL=DataApi.js.map

package/dist/graphql/GraphQLClient.d.ts

@@ -0,0 +1,45 @@
+import type { ApiClient } from '@microsoft/rayfin-lib';
+/**
+ * GraphQL request payload.
+ */
+export interface GraphQLRequest {
+    query: string;
+    variables?: Record<string, any>;
+    operationName?: string;
+}
+/**
+ * GraphQL response payload.
+ */
+export interface GraphQLResponse<T = any> {
+    data?: T;
+    errors?: Array<{
+        message: string;
+        locations?: Array<{
+            line: number;
+            column: number;
+        }>;
+        path?: Array<string | number>;
+        extensions?: Record<string, any>;
+    }>;
+}
+/**
+ * GraphQL client for executing queries and mutations.
+ */
+export declare class GraphQLClient {
+    private apiClient;
+    private endpoint;
+    constructor(apiClient: ApiClient, endpoint?: string);
+    /**
+     * Execute a GraphQL query or mutation.
+     */
+    request<T = any>(query: string, variables?: Record<string, any>, operationName?: string): Promise<T>;
+    /**
+     * Execute a GraphQL query.
+     */
+    query<T = any>(query: string, variables?: Record<string, any>): Promise<T>;
+    /**
+     * Execute a GraphQL mutation.
+     */
+    mutation<T = any>(mutation: string, variables?: Record<string, any>): Promise<T>;
+}
+//# sourceMappingURL=GraphQLClient.d.ts.map

package/dist/graphql/GraphQLClient.js

@@ -0,0 +1,45 @@
+/**
+ * GraphQL client for executing queries and mutations.
+ */
+export class GraphQLClient {
+    apiClient;
+    endpoint;
+    constructor(apiClient, endpoint = '/graphql') {
+        this.apiClient = apiClient;
+        this.endpoint = endpoint;
+    }
+    /**
+     * Execute a GraphQL query or mutation.
+     */
+    async request(query, variables, operationName) {
+        const payload = {
+            query,
+            variables,
+            operationName,
+        };
+        const response = await this.apiClient.post(this.endpoint, payload);
+        if (response.errors && response.errors.length > 0) {
+            const errorMessage = response.errors
+                .map((err) => err.message)
+                .join(', ');
+            throw new Error(`GraphQL errors: ${errorMessage}`);
+        }
+        if (response.data === undefined) {
+            throw new Error('GraphQL response contains no data');
+        }
+        return response.data;
+    }
+    /**
+     * Execute a GraphQL query.
+     */
+    async query(query, variables) {
+        return this.request(query, variables);
+    }
+    /**
+     * Execute a GraphQL mutation.
+     */
+    async mutation(mutation, variables) {
+        return this.request(mutation, variables);
+    }
+}
+//# sourceMappingURL=GraphQLClient.js.map

package/dist/graphql/GraphQLEntityClient.d.ts

@@ -0,0 +1,48 @@
+import type { GraphQLClient } from './GraphQLClient';
+import { GraphQLQueryBuilder } from './GraphQLQueryBuilder';
+import type { EntitySchema, CreateInput, UpdateInput, WhereUniqueInput, FilterInput, OrderByInput, FieldSelection } from './types';
+export declare class GraphQLEntityClient<TSchema extends EntitySchema, TEntity extends keyof TSchema> {
+    private graphqlClient;
+    private entityNameString;
+    constructor(graphqlClient: GraphQLClient, entityName: TEntity);
+    private lowercaseFirstLetter;
+    select<TFields extends FieldSelection<TSchema[TEntity]>>(fields: TFields): GraphQLQueryBuilder<TSchema, TEntity>;
+    where(conditions: FilterInput<TSchema[TEntity]>): GraphQLQueryBuilder<TSchema, TEntity>;
+    orderBy(order: OrderByInput<TSchema[TEntity]>): GraphQLQueryBuilder<TSchema, TEntity>;
+    first(count: number): GraphQLQueryBuilder<TSchema, TEntity>;
+    findMany(filter?: FilterInput<TSchema[TEntity]>): Promise<TSchema[TEntity][]>;
+    findFirst(filter?: FilterInput<TSchema[TEntity]>): Promise<TSchema[TEntity] | null>;
+    findById(id: string): Promise<TSchema[TEntity] | null>;
+    create(input: CreateInput<TSchema[TEntity]>): Promise<TSchema[TEntity]>;
+    update(where: WhereUniqueInput<TSchema[TEntity]>, data: UpdateInput<TSchema[TEntity]>): Promise<TSchema[TEntity]>;
+    delete(where: WhereUniqueInput<TSchema[TEntity]>): Promise<TSchema[TEntity]>;
+    upsert(where: WhereUniqueInput<TSchema[TEntity]>, create: CreateInput<TSchema[TEntity]>, update: UpdateInput<TSchema[TEntity]>): Promise<TSchema[TEntity]>;
+    protected buildCreateMutationString(input: CreateInput<TSchema[TEntity]>): string;
+    protected buildUpdateMutationString(where: WhereUniqueInput<TSchema[TEntity]>, data: UpdateInput<TSchema[TEntity]>): string;
+    protected buildDeleteMutationString(where: WhereUniqueInput<TSchema[TEntity]>): string;
+    protected getDefaultFields(data: any): string;
+    protected formatMutationInput(data: any): string;
+    /**
+     * Checks if a value represents a relationship object (has 'id' property)
+     */
+    private isRelationshipObject;
+    /**
+     * Extracts the ID value from a relationship object, handling both 'id' and 'Id' casing
+     */
+    private getRelationshipId;
+    /**
+     * Checks if a value is a primitive field (not a complex object)
+     */
+    private isPrimitiveField;
+    private formatValue;
+    protected extractId(where: WhereUniqueInput<TSchema[TEntity]>): string;
+    private extractMutationResult;
+    /**
+     * Transforms flat FK fields (e.g. category_id) in mutation responses back into
+     * nested relationship objects (e.g. category: { id: "..." }) based on the
+     * relationship keys present in the original input.
+     */
+    private nestRelationshipFields;
+    private isNotFoundError;
+}
+//# sourceMappingURL=GraphQLEntityClient.d.ts.map

package/dist/graphql/GraphQLEntityClient.js

@@ -0,0 +1,277 @@
+import { getPrimaryKeyField } from '@microsoft/rayfin-core';
+import { deserializeDabResponse } from '../utils/serialization';
+import { GraphQLQueryBuilder } from './GraphQLQueryBuilder';
+export class GraphQLEntityClient {
+    graphqlClient;
+    entityNameString;
+    constructor(graphqlClient, entityName) {
+        this.graphqlClient = graphqlClient;
+        this.entityNameString = String(entityName);
+    }
+    // Helper method to lowercase only the first letter of the entity name
+    lowercaseFirstLetter(str) {
+        if (!str)
+            return str;
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+    // === QUERY METHODS (return builders for fluent interface) ===
+    select(fields) {
+        return new GraphQLQueryBuilder(this.graphqlClient, this.entityNameString).select(fields);
+    }
+    where(conditions) {
+        return new GraphQLQueryBuilder(this.graphqlClient, this.entityNameString).where(conditions);
+    }
+    orderBy(order) {
+        return new GraphQLQueryBuilder(this.graphqlClient, this.entityNameString).orderBy(order);
+    }
+    first(count) {
+        return new GraphQLQueryBuilder(this.graphqlClient, this.entityNameString).first(count);
+    }
+    // === DIRECT QUERY METHODS ===
+    async findMany(filter) {
+        const builder = new GraphQLQueryBuilder(this.graphqlClient, this.entityNameString);
+        if (filter) {
+            builder.where(filter);
+        }
+        return builder.execute();
+    }
+    async findFirst(filter) {
+        const builder = new GraphQLQueryBuilder(this.graphqlClient, this.entityNameString).first(1);
+        if (filter) {
+            builder.where(filter);
+        }
+        const results = await builder.execute();
+        return results[0] || null;
+    }
+    async findById(id) {
+        const queryName = `${this.lowercaseFirstLetter(this.entityNameString)}_by_pk`;
+        const query = `
+      query {
+        ${queryName}(${getPrimaryKeyField()}: "${id}") {
+          ${getPrimaryKeyField()}
+        }
+      }
+    `;
+        try {
+            const result = await this.graphqlClient.query(query);
+            const entityData = result.data?.[queryName] || result[queryName] || null;
+            return entityData
+                ? deserializeDabResponse(entityData)
+                : null;
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    // === MUTATION METHODS ===
+    async create(input) {
+        const mutationName = `create${this.entityNameString}`;
+        const mutation = this.buildCreateMutationString(input);
+        const result = await this.graphqlClient.mutation(mutation);
+        const entityData = this.extractMutationResult(result, mutationName);
+        const deserialized = deserializeDabResponse(entityData);
+        return this.nestRelationshipFields(deserialized, input);
+    }
+    async update(where, data) {
+        const mutationName = `update${this.entityNameString}`;
+        const mutation = this.buildUpdateMutationString(where, data);
+        const result = await this.graphqlClient.mutation(mutation);
+        const entityData = this.extractMutationResult(result, mutationName);
+        const deserialized = deserializeDabResponse(entityData);
+        return this.nestRelationshipFields(deserialized, data);
+    }
+    async delete(where) {
+        const mutationName = `delete${this.entityNameString}`;
+        const mutation = this.buildDeleteMutationString(where);
+        const result = await this.graphqlClient.mutation(mutation);
+        const entityData = this.extractMutationResult(result, mutationName);
+        return deserializeDabResponse(entityData);
+    }
+    async upsert(where, create, update) {
+        const id = this.extractId(where);
+        const existing = await this.findById(id);
+        if (existing) {
+            return await this.update(where, update);
+        }
+        return await this.create(create);
+    }
+    // === PROTECTED MUTATION BUILDING METHODS (for testing access) ===
+    buildCreateMutationString(input) {
+        const mutationName = `create${this.entityNameString}`;
+        const fieldsToReturn = this.getDefaultFields(input);
+        return `
+      mutation {
+        ${mutationName}(item: ${this.formatMutationInput(input)}) {
+          ${fieldsToReturn}
+        }
+      }
+    `.trim();
+    }
+    buildUpdateMutationString(where, data) {
+        const mutationName = `update${this.entityNameString}`;
+        const id = this.extractId(where);
+        const fieldsToReturn = this.getDefaultFields(data);
+        return `
+      mutation {
+        ${mutationName}(
+          ${getPrimaryKeyField()}: "${id}",
+          item: ${this.formatMutationInput(data)}
+        ) {
+          ${fieldsToReturn}
+        }
+      }
+    `.trim();
+    }
+    buildDeleteMutationString(where) {
+        const mutationName = `delete${this.entityNameString}`;
+        const id = this.extractId(where);
+        return `
+      mutation {
+        ${mutationName}(${getPrimaryKeyField()}: "${id}") {
+          ${getPrimaryKeyField()}
+        }
+      }
+    `.trim();
+    }
+    // === PROTECTED HELPER METHODS (for testing access) ===
+    getDefaultFields(data) {
+        const fields = [];
+        // Process all entries with unified logic
+        Object.entries(data).forEach(([key, value]) => {
+            // Skip undefined values
+            if (value === undefined) {
+                return;
+            }
+            // Handle relationship objects by adding foreign key fields
+            if (this.isRelationshipObject(value)) {
+                const foreignKeyField = `${key}_${getPrimaryKeyField()}`;
+                if (!fields.includes(foreignKeyField)) {
+                    fields.push(foreignKeyField);
+                }
+            }
+            // Handle primitive fields (exclude other object types)
+            else if (this.isPrimitiveField(value)) {
+                fields.push(key);
+            }
+        });
+        // Ensure the PK field is always included and at the beginning
+        if (!fields.includes(getPrimaryKeyField())) {
+            fields.unshift(getPrimaryKeyField());
+        }
+        return fields.join('\n          ');
+    }
+    formatMutationInput(data) {
+        const entries = [];
+        // Process all entries with unified logic
+        Object.entries(data).forEach(([key, value]) => {
+            // Skip undefined values
+            if (value === undefined) {
+                return;
+            }
+            // Handle relationship objects by converting to foreign key
+            if (this.isRelationshipObject(value)) {
+                const foreignKeyField = `${key}_${getPrimaryKeyField()}`;
+                const foreignKeyValue = this.formatValue(this.getRelationshipId(value));
+                entries.push(`${foreignKeyField}: ${foreignKeyValue}`);
+            }
+            // Handle primitive fields (exclude other object types)
+            else if (this.isPrimitiveField(value)) {
+                entries.push(`${key}: ${this.formatValue(value)}`);
+            }
+        });
+        return `{ ${entries.join(', ')} }`;
+    }
+    /**
+     * Checks if a value represents a relationship object (has 'id' property)
+     */
+    isRelationshipObject(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !(value instanceof Date) &&
+            ('id' in value || 'Id' in value));
+    }
+    /**
+     * Extracts the ID value from a relationship object, handling both 'id' and 'Id' casing
+     */
+    getRelationshipId(value) {
+        if ('id' in value) {
+            return value.id;
+        }
+        if ('Id' in value) {
+            return value.Id;
+        }
+        throw new Error('No ID field found in relationship object');
+    }
+    /**
+     * Checks if a value is a primitive field (not a complex object)
+     */
+    isPrimitiveField(value) {
+        return !(typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value) &&
+            !(value instanceof Date));
+    }
+    // === PRIVATE HELPER METHODS ===
+    formatValue(value) {
+        if (typeof value === 'string') {
+            return `"${value
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, '\\n')
+                .replace(/\r/g, '\\r')
+                .replace(/\t/g, '\\t')}"`;
+        }
+        if (typeof value === 'boolean') {
+            return String(value);
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `"${value.toISOString()}"`;
+        }
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        return `"${String(value)}"`;
+    }
+    extractId(where) {
+        return where[getPrimaryKeyField()];
+    }
+    extractMutationResult(result, operationName) {
+        if (result?.data?.[operationName]) {
+            return result.data[operationName];
+        }
+        if (result[operationName]) {
+            return result[operationName];
+        }
+        throw new Error(`Failed to extract result from ${operationName} mutation`);
+    }
+    /**
+     * Transforms flat FK fields (e.g. category_id) in mutation responses back into
+     * nested relationship objects (e.g. category: { id: "..." }) based on the
+     * relationship keys present in the original input.
+     */
+    nestRelationshipFields(responseData, inputData) {
+        const result = { ...responseData };
+        Object.entries(inputData).forEach(([key, value]) => {
+            if (value !== undefined && this.isRelationshipObject(value)) {
+                const foreignKeyField = `${key}_${getPrimaryKeyField()}`;
+                if (foreignKeyField in result) {
+                    result[key] = { [getPrimaryKeyField()]: result[foreignKeyField] };
+                }
+            }
+        });
+        return result;
+    }
+    isNotFoundError(error) {
+        return (error?.message?.includes('not found') ||
+            error?.message?.includes('404') ||
+            error?.extensions?.code === 'NOT_FOUND');
+    }
+}
+//# sourceMappingURL=GraphQLEntityClient.js.map