adaptic-backend 1.0.351 → 1.0.352

package/esm/Configuration.mjs

@@ -0,0 +1,793 @@
+import { client as importedClient, getApolloModules } from './client.mjs';
+import { removeUndefinedProps } from './utils.mjs';
+/**
+ * CRUD operations for the Configuration model.
+ */
+const selectionSet = `
+    
+  id
+  configKey
+  configValue
+  type
+  scope
+  version
+  description
+  isActive
+  expiresAt
+  createdAt
+  updatedAt
+
+  `;
+export const Configuration = {
+    /**
+     * Create a new Configuration record.
+     * @param props - Properties for the new record.
+     * @param client - Apollo Client instance.
+     * @returns The created Configuration or null.
+     */
+    /**
+     * Create a new Configuration record.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Properties for the new record.
+     * @param globalClient - Apollo Client instance.
+     * @returns The created Configuration or null.
+     */
+    async create(props, globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const CREATE_ONE_CONFIGURATION = gql `
+              mutation createOneConfiguration($data: ConfigurationCreateInput!) {
+                createOneConfiguration(data: $data) {
+                  ${selectionSet}
+                }
+              }
+           `;
+                const variables = {
+                    data: {
+                        configKey: props.configKey !== undefined ? props.configKey : undefined,
+                        configValue: props.configValue !== undefined ? props.configValue : undefined,
+                        type: props.type !== undefined ? props.type : undefined,
+                        scope: props.scope !== undefined ? props.scope : undefined,
+                        version: props.version !== undefined ? props.version : undefined,
+                        description: props.description !== undefined ? props.description : undefined,
+                        isActive: props.isActive !== undefined ? props.isActive : undefined,
+                        expiresAt: props.expiresAt !== undefined ? props.expiresAt : undefined,
+                    },
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.mutate({
+                    mutation: CREATE_ONE_CONFIGURATION,
+                    variables: filteredVariables,
+                    // Don't cache mutations, but ensure we're using the freshest context
+                    fetchPolicy: 'no-cache'
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.createOneConfiguration) {
+                    return response.data.createOneConfiguration;
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Create multiple Configuration records.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Array of Configuration objects for the new records.
+     * @param globalClient - Apollo Client instance.
+     * @returns The count of created records or null.
+     */
+    async createMany(props, globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const CREATE_MANY_CONFIGURATION = gql `
+          mutation createManyConfiguration($data: [ConfigurationCreateManyInput!]!) {
+            createManyConfiguration(data: $data) {
+              count
+            }
+          }`;
+                const variables = {
+                    data: props.map(prop => ({
+                        configKey: prop.configKey !== undefined ? prop.configKey : undefined,
+                        configValue: prop.configValue !== undefined ? prop.configValue : undefined,
+                        type: prop.type !== undefined ? prop.type : undefined,
+                        scope: prop.scope !== undefined ? prop.scope : undefined,
+                        version: prop.version !== undefined ? prop.version : undefined,
+                        description: prop.description !== undefined ? prop.description : undefined,
+                        isActive: prop.isActive !== undefined ? prop.isActive : undefined,
+                        expiresAt: prop.expiresAt !== undefined ? prop.expiresAt : undefined,
+                    })),
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.mutate({
+                    mutation: CREATE_MANY_CONFIGURATION,
+                    variables: filteredVariables,
+                    // Don't cache mutations, but ensure we're using the freshest context
+                    fetchPolicy: 'no-cache'
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.createManyConfiguration) {
+                    return response.data.createManyConfiguration;
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Update a single Configuration record.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Properties to update.
+     * @param globalClient - Apollo Client instance.
+     * @returns The updated Configuration or null.
+     */
+    async update(props, globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const UPDATE_ONE_CONFIGURATION = gql `
+          mutation updateOneConfiguration($data: ConfigurationUpdateInput!, $where: ConfigurationWhereUniqueInput!) {
+            updateOneConfiguration(data: $data, where: $where) {
+              ${selectionSet}
+            }
+          }`;
+                const variables = {
+                    where: {
+                        id: props.id !== undefined ? props.id : undefined,
+                    },
+                    data: {
+                        id: props.id !== undefined ? {
+                            set: props.id
+                        } : undefined,
+                        configKey: props.configKey !== undefined ? {
+                            set: props.configKey
+                        } : undefined,
+                        configValue: props.configValue !== undefined ? {
+                            set: props.configValue
+                        } : undefined,
+                        type: props.type !== undefined ? {
+                            set: props.type
+                        } : undefined,
+                        scope: props.scope !== undefined ? {
+                            set: props.scope
+                        } : undefined,
+                        version: props.version !== undefined ? {
+                            set: props.version
+                        } : undefined,
+                        description: props.description !== undefined ? {
+                            set: props.description
+                        } : undefined,
+                        isActive: props.isActive !== undefined ? {
+                            set: props.isActive
+                        } : undefined,
+                        expiresAt: props.expiresAt !== undefined ? {
+                            set: props.expiresAt
+                        } : undefined,
+                        createdAt: props.createdAt !== undefined ? {
+                            set: props.createdAt
+                        } : undefined,
+                        updatedAt: props.updatedAt !== undefined ? {
+                            set: props.updatedAt
+                        } : undefined,
+                    },
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.mutate({
+                    mutation: UPDATE_ONE_CONFIGURATION,
+                    variables: filteredVariables,
+                    // Don't cache mutations, but ensure we're using the freshest context
+                    fetchPolicy: 'no-cache'
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.updateOneConfiguration) {
+                    return response.data.updateOneConfiguration;
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Upsert a single Configuration record.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Properties to update.
+     * @param globalClient - Apollo Client instance.
+     * @returns The updated Configuration or null.
+     */
+    async upsert(props, globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const UPSERT_ONE_CONFIGURATION = gql `
+          mutation upsertOneConfiguration($where: ConfigurationWhereUniqueInput!, $create: ConfigurationCreateInput!, $update: ConfigurationUpdateInput!) {
+            upsertOneConfiguration(where: $where, create: $create, update: $update) {
+              ${selectionSet}
+            }
+          }`;
+                const variables = {
+                    where: {
+                        id: props.id !== undefined ? props.id : undefined,
+                    },
+                    create: {
+                        configKey: props.configKey !== undefined ? props.configKey : undefined,
+                        configValue: props.configValue !== undefined ? props.configValue : undefined,
+                        type: props.type !== undefined ? props.type : undefined,
+                        scope: props.scope !== undefined ? props.scope : undefined,
+                        version: props.version !== undefined ? props.version : undefined,
+                        description: props.description !== undefined ? props.description : undefined,
+                        isActive: props.isActive !== undefined ? props.isActive : undefined,
+                        expiresAt: props.expiresAt !== undefined ? props.expiresAt : undefined,
+                    },
+                    update: {
+                        configKey: props.configKey !== undefined ? {
+                            set: props.configKey
+                        } : undefined,
+                        configValue: props.configValue !== undefined ? {
+                            set: props.configValue
+                        } : undefined,
+                        type: props.type !== undefined ? {
+                            set: props.type
+                        } : undefined,
+                        scope: props.scope !== undefined ? {
+                            set: props.scope
+                        } : undefined,
+                        version: props.version !== undefined ? {
+                            set: props.version
+                        } : undefined,
+                        description: props.description !== undefined ? {
+                            set: props.description
+                        } : undefined,
+                        isActive: props.isActive !== undefined ? {
+                            set: props.isActive
+                        } : undefined,
+                        expiresAt: props.expiresAt !== undefined ? {
+                            set: props.expiresAt
+                        } : undefined,
+                    },
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.mutate({
+                    mutation: UPSERT_ONE_CONFIGURATION,
+                    variables: filteredVariables,
+                    // Don't cache mutations, but ensure we're using the freshest context
+                    fetchPolicy: 'no-cache'
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.upsertOneConfiguration) {
+                    return response.data.upsertOneConfiguration;
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Update multiple Configuration records.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Array of Configuration objects for the updated records.
+     * @param globalClient - Apollo Client instance.
+     * @returns The count of created records or null.
+     */
+    async updateMany(props, globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const UPDATE_MANY_CONFIGURATION = gql `
+          mutation updateManyConfiguration($data: [ConfigurationCreateManyInput!]!) {
+            updateManyConfiguration(data: $data) {
+              count
+            }
+          }`;
+                const variables = props.map(prop => ({
+                    where: {
+                        id: prop.id !== undefined ? prop.id : undefined,
+                    },
+                    data: {
+                        id: prop.id !== undefined ? {
+                            set: prop.id
+                        } : undefined,
+                        configKey: prop.configKey !== undefined ? {
+                            set: prop.configKey
+                        } : undefined,
+                        configValue: prop.configValue !== undefined ? {
+                            set: prop.configValue
+                        } : undefined,
+                        type: prop.type !== undefined ? {
+                            set: prop.type
+                        } : undefined,
+                        scope: prop.scope !== undefined ? {
+                            set: prop.scope
+                        } : undefined,
+                        version: prop.version !== undefined ? {
+                            set: prop.version
+                        } : undefined,
+                        description: prop.description !== undefined ? {
+                            set: prop.description
+                        } : undefined,
+                        isActive: prop.isActive !== undefined ? {
+                            set: prop.isActive
+                        } : undefined,
+                        expiresAt: prop.expiresAt !== undefined ? {
+                            set: prop.expiresAt
+                        } : undefined,
+                        createdAt: prop.createdAt !== undefined ? {
+                            set: prop.createdAt
+                        } : undefined,
+                        updatedAt: prop.updatedAt !== undefined ? {
+                            set: prop.updatedAt
+                        } : undefined,
+                    },
+                }));
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.mutate({
+                    mutation: UPDATE_MANY_CONFIGURATION,
+                    variables: filteredVariables,
+                    // Don't cache mutations, but ensure we're using the freshest context
+                    fetchPolicy: 'no-cache'
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.updateManyConfiguration) {
+                    return response.data.updateManyConfiguration;
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Delete a single Configuration record.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Properties to identify the record to delete.
+     * @param globalClient - Apollo Client instance.
+     * @returns The deleted Configuration or null.
+     */
+    async delete(props, globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const DELETE_ONE_CONFIGURATION = gql `
+          mutation deleteOneConfiguration($where: ConfigurationWhereUniqueInput!) {
+            deleteOneConfiguration(where: $where) {
+              id
+            }
+          }`;
+                const variables = {
+                    where: {
+                        id: props.id ? props.id : undefined,
+                    }
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.mutate({
+                    mutation: DELETE_ONE_CONFIGURATION,
+                    variables: filteredVariables,
+                    // Don't cache mutations, but ensure we're using the freshest context
+                    fetchPolicy: 'no-cache'
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.deleteOneConfiguration) {
+                    return response.data.deleteOneConfiguration;
+                }
+                else {
+                    return null;
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Retrieve a single Configuration record by ID.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Properties to identify the record.
+     * @param globalClient - Apollo Client instance.
+     * @param whereInput - Optional custom where input.
+     * @returns The retrieved Configuration or null.
+     */
+    async get(props, globalClient, whereInput) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const GET_CONFIGURATION = gql `
+          query getConfiguration($where: ConfigurationWhereUniqueInput!) {
+            getConfiguration(where: $where) {
+              ${selectionSet}
+            }
+          }`;
+                const variables = {
+                    where: whereInput ? whereInput : {
+                        id: props.id !== undefined ? props.id : undefined,
+                    },
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.query({
+                    query: GET_CONFIGURATION,
+                    variables: filteredVariables,
+                    fetchPolicy: 'network-only', // Force network request to avoid stale cache
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                return response.data?.getConfiguration ?? null;
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a "No record found" error - this is an expected condition, not a failure
+                if (error.message === 'No Configuration found') {
+                    return null;
+                }
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Retrieve all Configurations records.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param globalClient - Apollo Client instance.
+     * @returns An array of Configuration records or null.
+     */
+    async getAll(globalClient) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const GET_ALL_CONFIGURATION = gql `
+          query getAllConfiguration {
+            configurations {
+              ${selectionSet}
+            }
+          }`;
+                const response = await client.query({
+                    query: GET_ALL_CONFIGURATION,
+                    fetchPolicy: 'network-only', // Force network request to avoid stale cache
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                return response.data?.configurations ?? null;
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a "No record found" error - this is an expected condition, not a failure
+                if (error.message === 'No Configuration found') {
+                    return null;
+                }
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    },
+    /**
+     * Find multiple Configuration records based on conditions.
+     * Enhanced with connection resilience against Prisma connection errors.
+     * @param props - Conditions to find records.
+     * @param globalClient - Apollo Client instance.
+     * @param whereInput - Optional custom where input.
+     * @returns An array of found Configuration records or null.
+     */
+    async findMany(props, globalClient, whereInput) {
+        // Maximum number of retries for database connection issues
+        const MAX_RETRIES = 3;
+        let retryCount = 0;
+        let lastError = null;
+        // Retry loop to handle potential database connection issues
+        while (retryCount < MAX_RETRIES) {
+            try {
+                const [modules, client] = await Promise.all([
+                    getApolloModules(),
+                    globalClient
+                        ? Promise.resolve(globalClient)
+                        : importedClient
+                ]);
+                const { gql, ApolloError } = modules;
+                const FIND_MANY_CONFIGURATION = gql `
+          query findManyConfiguration($where: ConfigurationWhereInput!) {
+            configurations(where: $where) {
+              ${selectionSet}
+            }
+          }`;
+                const variables = {
+                    where: whereInput ? whereInput : {
+                        id: props.id !== undefined ? {
+                            equals: props.id
+                        } : undefined,
+                    },
+                };
+                const filteredVariables = removeUndefinedProps(variables);
+                const response = await client.query({
+                    query: FIND_MANY_CONFIGURATION,
+                    variables: filteredVariables,
+                    fetchPolicy: 'network-only', // Force network request to avoid stale cache
+                });
+                if (response.errors && response.errors.length > 0)
+                    throw new Error(response.errors[0].message);
+                if (response && response.data && response.data.configurations) {
+                    return response.data.configurations;
+                }
+                else {
+                    return [];
+                }
+            }
+            catch (error) {
+                lastError = error;
+                // Check if this is a "No record found" error - this is an expected condition, not a failure
+                if (error.message === 'No Configuration found') {
+                    return null;
+                }
+                // Check if this is a database connection error that we should retry
+                const isConnectionError = error.message?.includes('Server has closed the connection') ||
+                    error.message?.includes('Cannot reach database server') ||
+                    error.message?.includes('Connection timed out') ||
+                    error.message?.includes('Accelerate') || // Prisma Accelerate proxy errors
+                    (error.networkError && error.networkError.message?.includes('Failed to fetch'));
+                if (isConnectionError && retryCount < MAX_RETRIES - 1) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 100; // Exponential backoff: 200ms, 400ms, 800ms
+                    console.warn("Database connection error, retrying...");
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                // Log the error and rethrow
+                console.error("Database error occurred:", error);
+                throw error;
+            }
+        }
+        // If we exhausted retries, throw the last error
+        throw lastError;
+    }
+};
+//# sourceMappingURL=Configuration.js.map