@ductape/sdk 0.0.4-v55 → 0.0.4-v57

package/dist/index.js

@@ -422,6 +422,9 @@ class Ductape {
         this._cacheService = null;
         this._jobsService = null;
         this._secretsService = null;
+        this._quotaService = null;
+        this._fallbackService = null;
+        this._healthcheckService = null;
         /**
          * Product-related operations for managing products.
          */
@@ -603,50 +606,6 @@ class Ductape {
                         return processorService.generateWebhookLink(data);
                     },
                 },
-                health: {
-                    /**
-                     * Creates a health check for an app.
-                     * @param {string} product - The product tag.
-                     * @param {Partial<IProductAppHealth>} data - The health check data.
-                     * @returns {Promise<void>} Resolves when the health check is created. Throws on error.
-                     */
-                    create: async (product, data) => {
-                        const builder = await this.getProductBuilder(product);
-                        return builder.createHealthcheck(data);
-                    },
-                    /**
-                     * Updates a health check by tag.
-                     * @param {string} product - The product tag.
-                     * @param {string} tag - The health check tag.
-                     * @param {Partial<IProductAppHealth>} data - The health check data to update.
-                     * @returns {Promise<void>} Resolves when the health check is updated. Throws on error.
-                     */
-                    update: async (product, tag, data) => {
-                        const builder = await this.getProductBuilder(product);
-                        return builder.updateHealthcheck(tag, data);
-                    },
-                    /**
-                     * Fetches a health check by access tag and tag.
-                     * @param {string} product - The product tag.
-                     * @param {string} access_tag - The app access tag.
-                     * @param {string} tag - The health check tag.
-                     * @returns {Promise<IProductAppHealth|null>} The fetched health check, or null if not found.
-                     */
-                    fetch: async (product, access_tag, tag) => {
-                        const builder = await this.getProductBuilder(product);
-                        return builder.fetchHealthcheck(access_tag, tag);
-                    },
-                    /**
-                     * Fetches all health checks for an app by access tag.
-                     * @param {string} product - The product tag.
-                     * @param {string} access_tag - The app access tag.
-                     * @returns {Promise<IProductAppHealth[]>} The list of health checks.
-                     */
-                    list: async (product, access_tag) => {
-                        const builder = await this.getProductBuilder(product);
-                        return builder.fetchHealthchecks(access_tag);
-                    },
-                },
             },
         };
         /**
@@ -760,58 +719,73 @@ class Ductape {
             },
         };
         /**
-         * Quota-related operations for managing product quotas.
+         * Quota-related operations for managing product quotas with weighted distribution.
          */
         this.quota = {
+            /**
+             * Defines a quota using code-first API.
+             * @param {IQuotaDefineOptions} options - The quota definition options.
+             * @param {string} [options.product] - The product tag (if provided, registers immediately).
+             * @param {string} options.tag - The quota tag.
+             * @param {string} [options.name] - The quota name.
+             * @param {string} [options.description] - The quota description.
+             * @param {Object} [options.input] - The input schema definition.
+             * @param {Function} options.handler - The handler function to configure the quota.
+             * @returns {Promise<IDefinedQuota>} The defined quota.
+             */
+            define: async (options) => {
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.define(options);
+            },
             /**
              * Creates a quota for a product.
              * @param {string} product - The product tag.
-             * @param {Partial<IProductQuota>} data - The quota data.
-             * @returns {Promise<void>} Resolves when the quota is created. Throws on error.
+             * @param {any} data - The quota data (schema or defined quota).
+             * @returns {Promise<any>} The created quota schema.
              */
             create: async (product, data) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.createQuota(data);
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.create(product, data);
             },
             /**
              * Fetches a quota by tag.
              * @param {string} product - The product tag.
              * @param {string} tag - The quota tag.
-             * @returns {IProductQuota|null} The fetched quota, or null if not found.
+             * @returns {Promise<any>} The fetched quota.
              */
             fetch: async (product, tag) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.fetchQuota(tag);
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.fetch(product, tag);
             },
             /**
              * Fetches all quotas for a product.
              * @param {string} product - The product tag.
-             * @returns {IProductQuota[]} The list of quotas.
+             * @returns {Promise<any[]>} The list of quotas.
              */
             list: async (product) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.fetchQuotas();
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.fetchAll(product);
             },
             /**
              * Updates a quota by tag.
              * @param {string} product - The product tag.
              * @param {string} tag - The quota tag.
-             * @param {Partial<IProductQuota>} data - The quota data to update.
-             * @returns {Promise<void>} Resolves when the quota is updated. Throws on error.
+             * @param {any} data - The quota data to update.
+             * @returns {Promise<any>} The updated quota schema.
              */
             update: async (product, tag, data) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.updateQuota(tag, data);
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.update(product, tag, data);
             },
             /**
              * Deletes a quota by tag.
              * @param {string} product - The product tag.
              * @param {string} tag - The quota tag.
-             * @returns {Promise<void>} Resolves when the quota is deleted. Throws on error.
+             * @returns {Promise<void>} Resolves when the quota is deleted.
              */
             delete: async (product, tag) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.deleteQuota(tag);
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.delete(product, tag);
             },
             /**
              * Runs a quota with weighted distribution.
@@ -826,60 +800,89 @@ class Ductape {
                 const quotaService = await this.createNewQuotaService();
                 return quotaService.run(data);
             },
+            /**
+             * Dispatches a quota for deferred execution.
+             * @param {Object} data - The quota dispatch input.
+             * @param {string} data.product - The product tag.
+             * @param {string} data.env - The environment slug.
+             * @param {string} data.tag - The quota tag.
+             * @param {Record<string, unknown>} data.input - The input data for the quota.
+             * @param {IDispatchSchedule} [data.schedule] - Optional schedule for deferred execution.
+             * @returns {Promise<{ jobId: string }>} The dispatch result with job ID.
+             */
+            dispatch: async (data) => {
+                const quotaService = await this.createNewQuotaService();
+                return quotaService.dispatch(data);
+            },
         };
         /**
-         * Fallback-related operations for managing product fallbacks.
+         * Fallback-related operations for managing product fallbacks with sequential failover.
          */
         this.fallback = {
+            /**
+             * Defines a fallback using code-first API.
+             * @param {IFallbackDefineOptions} options - The fallback definition options.
+             * @param {string} [options.product] - The product tag (if provided, registers immediately).
+             * @param {string} options.tag - The fallback tag.
+             * @param {string} [options.name] - The fallback name.
+             * @param {string} [options.description] - The fallback description.
+             * @param {Object} [options.input] - The input schema definition.
+             * @param {Function} options.handler - The handler function to configure the fallback.
+             * @returns {Promise<IDefinedFallback>} The defined fallback.
+             */
+            define: async (options) => {
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.define(options);
+            },
             /**
              * Creates a fallback for a product.
              * @param {string} product - The product tag.
-             * @param {Partial<IProductFallback>} data - The fallback data.
-             * @returns {Promise<void>} Resolves when the fallback is created. Throws on error.
+             * @param {any} data - The fallback data (schema or defined fallback).
+             * @returns {Promise<any>} The created fallback schema.
              */
             create: async (product, data) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.createFallback(data);
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.create(product, data);
             },
             /**
              * Fetches a fallback by tag.
              * @param {string} product - The product tag.
              * @param {string} tag - The fallback tag.
-             * @returns {IProductFallback|null} The fetched fallback, or null if not found.
+             * @returns {Promise<any>} The fetched fallback.
              */
             fetch: async (product, tag) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.fetchFallback(tag);
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.fetch(product, tag);
             },
             /**
              * Fetches all fallbacks for a product.
              * @param {string} product - The product tag.
-             * @returns {IProductFallback[]} The list of fallbacks.
+             * @returns {Promise<any[]>} The list of fallbacks.
              */
             list: async (product) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.fetchFallbacks();
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.fetchAll(product);
             },
             /**
              * Updates a fallback by tag.
              * @param {string} product - The product tag.
              * @param {string} tag - The fallback tag.
-             * @param {Partial<IProductFallback>} data - The fallback data to update.
-             * @returns {Promise<void>} Resolves when the fallback is updated. Throws on error.
+             * @param {any} data - The fallback data to update.
+             * @returns {Promise<any>} The updated fallback schema.
              */
             update: async (product, tag, data) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.updateFallback(tag, data);
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.update(product, tag, data);
             },
             /**
              * Deletes a fallback by tag.
              * @param {string} product - The product tag.
              * @param {string} tag - The fallback tag.
-             * @returns {Promise<void>} Resolves when the fallback is deleted. Throws on error.
+             * @returns {Promise<void>} Resolves when the fallback is deleted.
              */
             delete: async (product, tag) => {
-                const builder = await this.getProductBuilder(product);
-                return builder.deleteFallback(tag);
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.delete(product, tag);
             },
             /**
              * Runs a fallback with sequential failover.
@@ -894,6 +897,125 @@ class Ductape {
                 const fallbackService = await this.createNewFallbackService();
                 return fallbackService.run(data);
             },
+            /**
+             * Dispatches a fallback for deferred execution.
+             * @param {Object} data - The fallback dispatch input.
+             * @param {string} data.product - The product tag.
+             * @param {string} data.env - The environment slug.
+             * @param {string} data.tag - The fallback tag.
+             * @param {Record<string, unknown>} data.input - The input data for the fallback.
+             * @param {IDispatchSchedule} [data.schedule] - Optional schedule for deferred execution.
+             * @returns {Promise<{ jobId: string }>} The dispatch result with job ID.
+             */
+            dispatch: async (data) => {
+                const fallbackService = await this.createNewFallbackService();
+                return fallbackService.dispatch(data);
+            },
+        };
+        /**
+         * Healthcheck-related operations for managing product healthchecks.
+         */
+        this.health = {
+            /**
+             * Defines a healthcheck using code-first API.
+             * @param {IHealthcheckDefineOptions} options - The healthcheck definition options.
+             * @param {string} [options.product] - The product tag (if provided, registers immediately).
+             * @param {string} options.tag - The healthcheck tag.
+             * @param {string} [options.name] - The healthcheck name.
+             * @param {string} [options.description] - The healthcheck description.
+             * @param {Function} options.handler - The handler function to configure the healthcheck.
+             * @returns {Promise<IDefinedHealthcheck>} The defined healthcheck.
+             */
+            define: async (options) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.define(options);
+            },
+            /**
+             * Creates a healthcheck for a product.
+             * @param {string} product - The product tag.
+             * @param {Object} data - The healthcheck data (schema or defined healthcheck).
+             * @returns {Promise<IHealthcheckSchema>} The created healthcheck schema.
+             */
+            create: async (product, data) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.create(product, data);
+            },
+            /**
+             * Fetches a healthcheck by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The healthcheck tag.
+             * @returns {Promise<IHealthcheckSchema>} The fetched healthcheck.
+             */
+            fetch: async (product, tag) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.fetch(product, tag);
+            },
+            /**
+             * Fetches all healthchecks for a product.
+             * @param {string} product - The product tag.
+             * @returns {Promise<IHealthcheckSchema[]>} The list of healthchecks.
+             */
+            list: async (product) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.fetchAll(product);
+            },
+            /**
+             * Updates a healthcheck by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The healthcheck tag.
+             * @param {Object} data - The healthcheck data to update.
+             * @returns {Promise<IHealthcheckSchema>} The updated healthcheck schema.
+             */
+            update: async (product, tag, data) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.update(product, tag, data);
+            },
+            /**
+             * Deletes a healthcheck by tag.
+             * @param {string} product - The product tag.
+             * @param {string} tag - The healthcheck tag.
+             * @returns {Promise<void>} Resolves when the healthcheck is deleted.
+             */
+            delete: async (product, tag) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.delete(product, tag);
+            },
+            /**
+             * Gets the current status of a healthcheck.
+             * @param {Object} options - The status check options.
+             * @param {string} options.product - The product tag.
+             * @param {string} options.env - The environment slug.
+             * @param {string} options.tag - The healthcheck tag.
+             * @returns {Promise<IHealthcheckStatus>} The healthcheck status.
+             */
+            status: async (options) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.getStatus(options);
+            },
+            /**
+             * Manually triggers a healthcheck run.
+             * @param {Object} options - The run options.
+             * @param {string} options.product - The product tag.
+             * @param {string} options.env - The environment slug.
+             * @param {string} options.tag - The healthcheck tag.
+             * @returns {Promise<IHealthcheckRunResult>} The result of the healthcheck run.
+             */
+            run: async (options) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.run(options);
+            },
+            /**
+             * Checks the health of a service (alias for status).
+             * @param {Object} options - The check options.
+             * @param {string} options.product - The product tag.
+             * @param {string} options.env - The environment slug.
+             * @param {string} options.tag - The healthcheck tag.
+             * @returns {Promise<IHealthcheckStatus>} The healthcheck status.
+             */
+            check: async (options) => {
+                const healthcheckService = await this.createNewHealthcheckService();
+                return healthcheckService.check(options);
+            },
         };
         /**
          * Storage-related operations for managing product storages.
@@ -1980,11 +2102,535 @@ class Ductape {
          */
         this.graph = {
             /**
-             * Get the underlying GraphService instance
+             * Get the underlying GraphService instance for advanced operations.
+             * @returns {Promise<GraphService>} The graph service instance.
              */
             getService: async () => {
                 return this.createNewGraphService();
             },
+            // ==================== CRUD OPERATIONS ====================
+            /**
+             * Creates a graph configuration for a product.
+             * @param {any} graphConfig - The graph configuration.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<void>} Resolves when the graph is created.
+             */
+            create: async (graphConfig, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.create(graphConfig, productTag);
+            },
+            /**
+             * Fetches a graph configuration by tag.
+             * @param {string} graphTag - The graph tag.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<any>} The fetched graph configuration.
+             */
+            fetch: async (graphTag, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.fetch(graphTag, productTag);
+            },
+            /**
+             * Fetches all graph configurations for a product.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<any[]>} The list of graph configurations.
+             */
+            list: async (productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.fetchAll(productTag);
+            },
+            /**
+             * Updates a graph configuration by tag.
+             * @param {string} graphTag - The graph tag.
+             * @param {any} updates - The updates to apply.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<void>} Resolves when the graph is updated.
+             */
+            update: async (graphTag, updates, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.update(graphTag, updates, productTag);
+            },
+            /**
+             * Deletes a graph configuration by tag.
+             * @param {string} graphTag - The graph tag.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<void>} Resolves when the graph is deleted.
+             */
+            delete: async (graphTag, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.delete(graphTag, productTag);
+            },
+            // ==================== CONNECTION MANAGEMENT ====================
+            /**
+             * Connects to a graph database.
+             * @param {any} config - The connection configuration.
+             * @returns {Promise<any>} The connection result.
+             */
+            connect: async (config) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.connect(config);
+            },
+            /**
+             * Disconnects from the current graph database.
+             * @returns {Promise<void>} Resolves when disconnected.
+             */
+            disconnect: async () => {
+                const graphService = await this.createNewGraphService();
+                return graphService.disconnect();
+            },
+            /**
+             * Closes all graph database connections.
+             * @returns {Promise<void>} Resolves when all connections are closed.
+             */
+            closeAll: async () => {
+                const graphService = await this.createNewGraphService();
+                return graphService.closeAll();
+            },
+            /**
+             * Tests a connection to a graph database without persisting.
+             * @param {any} config - The connection configuration.
+             * @returns {Promise<any>} The test connection result.
+             */
+            testConnection: async (config) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.testConnection(config);
+            },
+            // ==================== NODE OPERATIONS ====================
+            /**
+             * Creates a node in the graph.
+             * @param {any} options - The node creation options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The created node result.
+             */
+            createNode: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.createNode(options, transaction);
+            },
+            /**
+             * Finds nodes by criteria.
+             * @param {any} options - The find options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The found nodes result.
+             */
+            findNodes: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.findNodes(options, transaction);
+            },
+            /**
+             * Finds a node by ID.
+             * @param {string | number} id - The node ID.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The found node or null.
+             */
+            findNodeById: async (id, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.findNodeById(id, transaction);
+            },
+            /**
+             * Updates a node.
+             * @param {any} options - The update options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The updated node result.
+             */
+            updateNode: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.updateNode(options, transaction);
+            },
+            /**
+             * Deletes a node.
+             * @param {any} options - The delete options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The delete result.
+             */
+            deleteNode: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.deleteNode(options, transaction);
+            },
+            /**
+             * Merges a node (create or update).
+             * @param {any} options - The merge options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The merge result.
+             */
+            mergeNode: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.mergeNode(options, transaction);
+            },
+            /**
+             * Adds labels to an existing node.
+             * @param {any} options - The add labels options (id, labels).
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The result with added labels.
+             */
+            addLabels: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.addLabels(options, transaction);
+            },
+            /**
+             * Removes labels from an existing node.
+             * @param {any} options - The remove labels options (id, labels).
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The result with removed labels.
+             */
+            removeLabels: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.removeLabels(options, transaction);
+            },
+            /**
+             * Sets labels on a node (replaces all existing labels).
+             * @param {any} options - The set labels options (id, labels).
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The result with previous and new labels.
+             */
+            setLabels: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.setLabels(options, transaction);
+            },
+            // ==================== RELATIONSHIP OPERATIONS ====================
+            /**
+             * Creates a relationship between nodes.
+             * @param {any} options - The relationship creation options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The created relationship result.
+             */
+            createRelationship: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.createRelationship(options, transaction);
+            },
+            /**
+             * Finds relationships by criteria.
+             * @param {any} options - The find options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The found relationships result.
+             */
+            findRelationships: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.findRelationships(options, transaction);
+            },
+            /**
+             * Finds a relationship by ID.
+             * @param {string | number} id - The relationship ID.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The found relationship or null.
+             */
+            findRelationshipById: async (id, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.findRelationshipById(id, transaction);
+            },
+            /**
+             * Updates a relationship.
+             * @param {any} options - The update options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The updated relationship result.
+             */
+            updateRelationship: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.updateRelationship(options, transaction);
+            },
+            /**
+             * Deletes a relationship.
+             * @param {any} options - The delete options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The delete result.
+             */
+            deleteRelationship: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.deleteRelationship(options, transaction);
+            },
+            /**
+             * Merges a relationship (create or update).
+             * @param {any} options - The merge options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The merge result.
+             */
+            mergeRelationship: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.mergeRelationship(options, transaction);
+            },
+            // ==================== TRAVERSAL OPERATIONS ====================
+            /**
+             * Traverses the graph from a starting node.
+             * @param {any} options - The traversal options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The traversal result.
+             */
+            traverse: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.traverse(options, transaction);
+            },
+            /**
+             * Finds the shortest path between two nodes.
+             * @param {any} options - The shortest path options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The shortest path result.
+             */
+            shortestPath: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.shortestPath(options, transaction);
+            },
+            /**
+             * Finds all paths between two nodes.
+             * @param {any} options - The all paths options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The all paths result.
+             */
+            allPaths: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.allPaths(options, transaction);
+            },
+            /**
+             * Gets the neighborhood of a node.
+             * @param {any} options - The neighborhood options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The neighborhood result.
+             */
+            getNeighborhood: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.getNeighborhood(options, transaction);
+            },
+            /**
+             * Finds connected components in the graph.
+             * @param {any} options - The connected components options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The connected components result.
+             */
+            findConnectedComponents: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.findConnectedComponents(options, transaction);
+            },
+            // ==================== QUERY OPERATIONS ====================
+            /**
+             * Executes a raw Cypher query against the graph database.
+             * @param {string} query - The Cypher query string.
+             * @param {Record<string, any>} [params] - Query parameters.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The query result.
+             */
+            query: async (query, params, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.query(query, params, transaction);
+            },
+            /**
+             * Gets graph statistics.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The graph statistics.
+             */
+            getStatistics: async (transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.getStatistics(transaction);
+            },
+            /**
+             * Counts nodes matching criteria.
+             * @param {string[]} [labels] - Node labels to filter by.
+             * @param {any} [where] - Where clause for filtering.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The count result.
+             */
+            countNodes: async (labels, where, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.countNodes(labels, where, transaction);
+            },
+            /**
+             * Counts relationships matching criteria.
+             * @param {string[]} [types] - Relationship types to filter by.
+             * @param {any} [where] - Where clause for filtering.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The count result.
+             */
+            countRelationships: async (types, where, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.countRelationships(types, where, transaction);
+            },
+            /**
+             * Performs full-text search.
+             * @param {any} options - The search options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The search result.
+             */
+            fullTextSearch: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.fullTextSearch(options, transaction);
+            },
+            /**
+             * Performs vector similarity search.
+             * @param {any} options - The search options.
+             * @param {any} [transaction] - Optional transaction.
+             * @returns {Promise<any>} The search result.
+             */
+            vectorSearch: async (options, transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.vectorSearch(options, transaction);
+            },
+            // ==================== SCHEMA OPERATIONS ====================
+            /**
+             * Creates a node index.
+             * @param {any} options - The index creation options.
+             * @returns {Promise<any>} The index creation result.
+             */
+            createNodeIndex: async (options) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.createNodeIndex(options);
+            },
+            /**
+             * Creates a node constraint.
+             * @param {any} options - The constraint creation options.
+             * @returns {Promise<any>} The constraint creation result.
+             */
+            createNodeConstraint: async (options) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.createNodeConstraint(options);
+            },
+            /**
+             * Creates a relationship index.
+             * @param {any} options - The index creation options.
+             * @returns {Promise<any>} The index creation result.
+             */
+            createRelationshipIndex: async (options) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.createRelationshipIndex(options);
+            },
+            /**
+             * Lists all indexes.
+             * @returns {Promise<any>} The list of indexes.
+             */
+            listIndexes: async () => {
+                const graphService = await this.createNewGraphService();
+                return graphService.listIndexes();
+            },
+            /**
+             * Lists all constraints.
+             * @returns {Promise<any>} The list of constraints.
+             */
+            listConstraints: async () => {
+                const graphService = await this.createNewGraphService();
+                return graphService.listConstraints();
+            },
+            /**
+             * Drops an index by name.
+             * @param {string} name - The index name.
+             * @returns {Promise<any>} The drop result.
+             */
+            dropIndex: async (name) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.dropIndex(name);
+            },
+            /**
+             * Drops a constraint by name.
+             * @param {string} name - The constraint name.
+             * @returns {Promise<any>} The drop result.
+             */
+            dropConstraint: async (name) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.dropConstraint(name);
+            },
+            /**
+             * Lists all node labels.
+             * @returns {Promise<any>} The list of labels.
+             */
+            listLabels: async () => {
+                const graphService = await this.createNewGraphService();
+                return graphService.listLabels();
+            },
+            /**
+             * Lists all relationship types.
+             * @returns {Promise<any>} The list of relationship types.
+             */
+            listRelationshipTypes: async () => {
+                const graphService = await this.createNewGraphService();
+                return graphService.listRelationshipTypes();
+            },
+            // ==================== ACTION OPERATIONS ====================
+            /**
+             * Creates a graph action.
+             * @param {any} options - The action creation options.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<any>} The created action.
+             */
+            createAction: async (options, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.createAction(options, productTag);
+            },
+            /**
+             * Lists graph actions.
+             * @param {string} [graphTag] - The graph tag.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<any>} The list of actions.
+             */
+            listActions: async (graphTag, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.listActions(graphTag, productTag);
+            },
+            /**
+             * Gets a graph action by tag.
+             * @param {string} actionTag - The action tag.
+             * @param {string} [graphTag] - The graph tag.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<any>} The action or null.
+             */
+            getAction: async (actionTag, graphTag, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.getAction(actionTag, graphTag, productTag);
+            },
+            /**
+             * Updates a graph action.
+             * @param {string} actionTag - The action tag.
+             * @param {any} updates - The updates to apply.
+             * @param {string} [graphTag] - The graph tag.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<any>} The updated action.
+             */
+            updateAction: async (actionTag, updates, graphTag, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.updateAction(actionTag, updates, graphTag, productTag);
+            },
+            /**
+             * Deletes a graph action.
+             * @param {string} actionTag - The action tag.
+             * @param {string} [graphTag] - The graph tag.
+             * @param {string} [productTag] - The product tag.
+             * @returns {Promise<void>} Resolves when the action is deleted.
+             */
+            deleteAction: async (actionTag, graphTag, productTag) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.deleteAction(actionTag, graphTag, productTag);
+            },
+            // ==================== TRANSACTION OPERATIONS ====================
+            /**
+             * Begins a new transaction.
+             * @param {any} [options] - Transaction options.
+             * @returns {Promise<any>} The transaction object.
+             */
+            beginTransaction: async (options) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.beginTransaction(options);
+            },
+            /**
+             * Commits a transaction.
+             * @param {any} transaction - The transaction to commit.
+             * @returns {Promise<void>} Resolves when committed.
+             */
+            commitTransaction: async (transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.commitTransaction(transaction);
+            },
+            /**
+             * Rolls back a transaction.
+             * @param {any} transaction - The transaction to rollback.
+             * @returns {Promise<void>} Resolves when rolled back.
+             */
+            rollbackTransaction: async (transaction) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.rollbackTransaction(transaction);
+            },
+            // ==================== DISPATCH OPERATIONS ====================
+            /**
+             * Dispatches a graph operation for deferred execution.
+             * @param {any} data - The dispatch input.
+             * @returns {Promise<any>} The dispatch result.
+             */
+            dispatch: async (data) => {
+                const graphService = await this.createNewGraphService();
+                return graphService.dispatch(data);
+            },
         };
         /**
          * Workflow service for building and executing durable workflows.
@@ -3745,33 +4391,63 @@ class Ductape {
     }
     /**
      * Create a new QuotaService instance with authenticated config
-     * @returns QuotaService instance
+     * @returns QuotaService instance (cached)
      */
     async createNewQuotaService() {
         const subCheck = false;
         await this.initUserAuth(subCheck);
-        return new resilience_1.QuotaService({
-            workspace_id: this.workspace_id,
-            public_key: this.public_key,
-            user_id: this.user_id,
-            token: this.token,
-            env_type: this.environment,
-        });
+        if (!this._quotaService) {
+            this._quotaService = new resilience_1.QuotaService({
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                token: this.token,
+                env_type: this.environment,
+                redis_client: this.redisClient,
+                queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+            });
+        }
+        return this._quotaService;
     }
     /**
      * Create a new FallbackService instance with authenticated config
-     * @returns FallbackService instance
+     * @returns FallbackService instance (cached)
      */
     async createNewFallbackService() {
         const subCheck = false;
         await this.initUserAuth(subCheck);
-        return new resilience_1.FallbackService({
-            workspace_id: this.workspace_id,
-            public_key: this.public_key,
-            user_id: this.user_id,
-            token: this.token,
-            env_type: this.environment,
-        });
+        if (!this._fallbackService) {
+            this._fallbackService = new resilience_1.FallbackService({
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                token: this.token,
+                env_type: this.environment,
+                redis_client: this.redisClient,
+                queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+            });
+        }
+        return this._fallbackService;
+    }
+    /**
+     * Create a new HealthcheckService instance with authenticated config
+     * @returns HealthcheckService instance (cached)
+     */
+    async createNewHealthcheckService() {
+        const subCheck = false;
+        await this.initUserAuth(subCheck);
+        if (!this._healthcheckService) {
+            this._healthcheckService = new resilience_1.HealthcheckService({
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                token: this.token,
+                env_type: this.environment,
+                redis_client: this.redisClient,
+                queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+            });
+        }
+        return this._healthcheckService;
     }
     async fetchSession() {
         try {