@ductape/sdk 0.0.4-v59 → 0.0.4-v60

package/dist/index.d.ts

@@ -4,12 +4,12 @@ import { PublicStates } from './types/enums';
 import { DatabaseService, IActionCreateOptions, IActionUpdateOptions, ISimpleSchemaDefinition, ISimpleCreateOptions, ISimpleDropOptions, ISimpleFieldDefinition, SimpleFieldType, ISimpleIndexOptions, ISchemaOperationResult, IIndexFieldDefinition, ITableSchema, IIndexInfo } from './database';
 import { IConstraintDefinition as IMigrationConstraintDefinition } from './database/types/migration.interface';
 import { IDBActionDispatchInput } from './types/processor.types';
-import { GraphService } from './graph';
+import { GraphService, IGraphConfig } from './graph';
 import { WorkflowService } from './workflows';
 import { IHealthcheckDefineOptions, IDefinedHealthcheck, IQuotaDefineOptions, IDefinedQuota, IFallbackDefineOptions, IDefinedFallback } from './resilience';
 import { AgentsService } from './agents';
 import { ModelService } from './models';
-import { VectorDatabaseService } from './vector';
+import { ICreateVectorDbOptions, VectorDatabaseService } from './vector';
 import { IShareCredentialsConfig } from './apps/utils/credential-manager';
 import { IOAuthConfig } from './apps/utils/oauth-manager';
 import { JobsService, JobStatus, IJobListOptions, ICancelOptions, IRetryOptions, IRescheduleOptions, IJobWebhookConfig } from './jobs';
@@ -258,7 +258,7 @@ export interface IDuctape {
 export default class Ductape implements IDuctape {
     private user_id;
     private workspace_id;
-    private private_key;
+    private accessKey;
     private public_key;
     private session;
     private token;
@@ -279,6 +279,7 @@ export default class Ductape implements IDuctape {
     private _cacheService;
     private _jobsService;
     private _secretsService;
+    private _privateKey;
     private _quotaService;
     private _fallbackService;
     private _healthcheckService;
@@ -294,7 +295,7 @@ export default class Ductape implements IDuctape {
     healthCheckWorker: any;
     healthCheckUpdaterWorker: any;
     private loadRedis;
-    constructor({ workspace_id, private_key, user_id, env_type, redis_url }: IDuctapeInit);
+    constructor({ accessKey, env_type, redis_url }: IDuctapeInit);
     private loadBullMQ;
     /**
      * Connects to Redis and initializes job and health check queues and workers.
@@ -828,7 +829,14 @@ export default class Ductape implements IDuctape {
          * @param {IProductStorage} data - The storage data.
          * @returns {Promise<void>} Resolves when the storage is created. Throws on error.
          */
-        create: (product: string, data: IProductStorage) => Promise<void>;
+        create: (data: IProductStorage & {
+            product: string;
+        }) => Promise<void>;
+        /**
+         * Creates a storage for a product (alternative method).
+          const builder = await this.getProductBuilder(product);
+          return builder.createStorage(data);
+        },
         /**
          * Fetches all storages for a product.
          * @param {string} product - The product tag.
@@ -1014,14 +1022,16 @@ export default class Ductape implements IDuctape {
     /**
      * Events-related operations for managing product events (message brokers).
      */
-    events: {
+    messaging: {
         /**
          * Creates a message broker for a product.
          * @param {string} product - The product tag.
          * @param {Partial<IProductMessageBroker>} data - The message broker data.
          * @returns {Promise<void>} Resolves when the message broker is created. Throws on error.
          */
-        create: (product: string, data: Partial<IProductMessageBroker>) => Promise<void>;
+        create: (data: Partial<IProductMessageBroker> & {
+            product: string;
+        }) => Promise<void>;
         /**
          * Fetches all message brokers for a product.
          * @param {string} product - The product tag.
@@ -1093,25 +1103,25 @@ export default class Ductape implements IDuctape {
          *   message: { orderId: '123', status: 'pending' }
          * });
          */
-        publish: (data: {
+        produce: (data: {
             product: string;
             env: string;
             event: string;
             message: Record<string, unknown>;
         }) => Promise<import("./brokers").IPublishResult>;
         /**
-         * Subscribes to a message broker topic.
+         * consume to a message broker topic.
          * @param data - The subscribe input.
          * @returns The result of the subscribe operation.
          * @example
-         * await ductape.events.subscribe({
+         * await ductape.events.consume({
          *   product: 'my-product',
          *   env: 'production',
          *   event: 'broker-tag:topic-tag',
          *   callback: async (message) => console.log(message)
          * });
          */
-        subscribe: (data: {
+        consume: (data: {
             product: string;
             env: string;
             event: string;
@@ -1551,28 +1561,30 @@ export default class Ductape implements IDuctape {
          * @param {string} [productTag] - The product tag.
          * @returns {Promise<void>} Resolves when the graph is created.
          */
-        create: (graphConfig: any, productTag?: string) => Promise<void>;
+        create: (graphConfig: IGraphConfig & {
+            product: string;
+        }) => Promise<void>;
         /**
          * Fetches a graph configuration by tag.
-         * @param {string} graphTag - The graph tag.
          * @param {string} [productTag] - The product tag.
+         * @param {string} graphTag - The graph tag.
          * @returns {Promise<any>} The fetched graph configuration.
          */
-        fetch: (graphTag: string, productTag?: string) => Promise<import("./graph").IGraphConfig>;
+        fetch: (productTag: string, graphTag: string) => Promise<IGraphConfig>;
         /**
          * Fetches all graph configurations for a product.
          * @param {string} [productTag] - The product tag.
          * @returns {Promise<any[]>} The list of graph configurations.
          */
-        list: (productTag?: string) => Promise<import("./graph").IGraphConfig[]>;
+        list: (productTag?: string) => Promise<IGraphConfig[]>;
         /**
          * Updates a graph configuration by tag.
+         * @param {string} [productTag] - The product 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: (graphTag: string, updates: any, productTag?: string) => Promise<void>;
+        update: (productTag: string, graphTag: string, updates: Partial<IGraphConfig>) => Promise<void>;
         /**
          * Deletes a graph configuration by tag.
          * @param {string} graphTag - The graph tag.
@@ -1965,9 +1977,342 @@ export default class Ductape implements IDuctape {
      */
     vector: {
         /**
-         * Get the underlying VectorDatabaseService instance
+         * Get the underlying VectorDatabaseService instance for advanced operations.
+         * @returns {Promise<VectorDatabaseService>} The vector database service instance.
          */
         getService: () => Promise<VectorDatabaseService>;
+        /**
+         * Creates a vector database configuration for a product.
+         * @param {ICreateVectorDbOptions} options - The vector configuration options.
+         * @returns {Promise<void>} Resolves when the vector config is created.
+         */
+        create: (options: ICreateVectorDbOptions) => Promise<void>;
+        /**
+         * Fetches a vector database configuration by tag.
+         * @param {IFetchVectorOptions} options - The fetch options.
+         * @returns {Promise<IProductVector | null>} The fetched vector configuration.
+         */
+        fetch: (options: import("./vector/vector-database.service").IFetchVectorOptions) => Promise<import("./types").IProductVector>;
+        /**
+         * Fetches all vector database configurations for a product.
+         * @param {object} options - The fetch options containing product tag.
+         * @returns {Promise<IProductVector[]>} The list of vector configurations.
+         */
+        list: (options: {
+            product: string;
+        }) => Promise<import("./types").IProductVector[]>;
+        /**
+         * Updates a vector database configuration.
+         * @param {IUpdateVectorDbOptions} options - The update options.
+         * @returns {Promise<void>} Resolves when the vector config is updated.
+         */
+        update: (options: import("./vector/vector-database.service").IUpdateVectorDbOptions) => Promise<void>;
+        /**
+         * Deletes a vector database configuration.
+         * @param {IDeleteVectorConfigOptions} options - The delete options.
+         * @returns {Promise<void>} Resolves when the vector config is deleted.
+         */
+        delete: (options: import("./vector/vector-database.service").IDeleteVectorConfigOptions) => Promise<void>;
+        /**
+         * Connects to a vector database.
+         * @param {object} options - Connection options with product, env, and vector.
+         * @returns {Promise<VectorService>} The connected vector service.
+         */
+        connect: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").VectorService>;
+        /**
+         * Disconnects from a specific vector database.
+         * @param {object} options - Disconnect options with product, env, and vector.
+         * @returns {Promise<void>} Resolves when disconnected.
+         */
+        disconnect: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<void>;
+        /**
+         * Disconnects all cached vector database connections.
+         * @returns {Promise<void>} Resolves when all connections are closed.
+         */
+        disconnectAll: () => Promise<void>;
+        /**
+         * Query vectors by similarity.
+         * @param {IProductVectorQueryOptions} options - The query options.
+         * @returns {Promise<IQueryVectorsResult>} The query results.
+         */
+        query: (options: import("./vector/vector-database.service").IProductVectorQueryOptions) => Promise<import("./vector").IQueryVectorsResult>;
+        /**
+         * Upsert vectors (insert or update).
+         * @param {IProductVectorUpsertOptions} options - The upsert options.
+         * @returns {Promise<IUpsertVectorsResult>} The upsert result.
+         */
+        upsert: (options: import("./vector/vector-database.service").IProductVectorUpsertOptions) => Promise<import("./vector").IUpsertVectorsResult>;
+        /**
+         * Fetch vectors by IDs.
+         * @param {IProductVectorFetchOptions} options - The fetch options.
+         * @returns {Promise<IFetchVectorsResult>} The fetched vectors.
+         */
+        fetchVectors: (options: import("./vector/vector-database.service").IProductVectorFetchOptions) => Promise<import("./vector").IFetchVectorsResult>;
+        /**
+         * Delete vectors by IDs.
+         * @param {IProductVectorDeleteOptions} options - The delete options.
+         * @returns {Promise<IDeleteVectorsResult>} The delete result.
+         */
+        deleteVectors: (options: import("./vector/vector-database.service").IProductVectorDeleteOptions) => Promise<import("./vector").IDeleteVectorsResult>;
+        /**
+         * Find similar vectors to a given vector.
+         * @param {object} options - Find similar options with product, env, tag, vector, and topK.
+         * @returns {Promise<IQueryVectorsResult>} The similar vectors.
+         */
+        findSimilar: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            values: number[];
+            topK?: number;
+            filter?: any;
+            namespace?: string;
+            includeValues?: boolean;
+            includeMetadata?: boolean;
+        }) => Promise<import("./vector").IQueryVectorsResult>;
+        /**
+         * Upsert a single vector.
+         * @param {object} options - Single vector upsert options.
+         * @returns {Promise<IUpsertVectorsResult>} The upsert result.
+         */
+        upsertOne: (options: {
+            product: string;
+            env: string;
+            tag: string;
+            id: string;
+            values: number[];
+            metadata?: Record<string, unknown>;
+            namespace?: string;
+        }) => Promise<import("./vector").IUpsertVectorsResult>;
+        /**
+         * Fetch a single vector by ID.
+         * @param {object} options - Single vector fetch options.
+         * @returns {Promise<IVector | null>} The fetched vector or null.
+         */
+        fetchOne: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            namespace?: string;
+        }) => Promise<import("./vector").IVector>;
+        /**
+         * Update a single vector.
+         * @param {object} options - Update options.
+         * @returns {Promise<IUpdateVectorResult>} The update result.
+         */
+        updateVector: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            values?: number[];
+            setMetadata?: Record<string, unknown>;
+            mergeMetadata?: Record<string, unknown>;
+            namespace?: string;
+        }) => Promise<import("./vector").IUpdateVectorResult>;
+        /**
+         * Update vector metadata.
+         * @param {object} options - Update metadata options.
+         * @returns {Promise<IUpdateVectorResult>} The update result.
+         */
+        updateMetadata: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            metadata: Record<string, unknown>;
+            merge?: boolean;
+            namespace?: string;
+        }) => Promise<import("./vector").IUpdateVectorResult>;
+        /**
+         * Delete vectors by IDs (convenience method).
+         * @param {object} options - Delete by IDs options.
+         * @returns {Promise<IDeleteVectorsResult>} The delete result.
+         */
+        deleteByIds: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            ids: string[];
+            namespace?: string;
+        }) => Promise<import("./vector").IDeleteVectorsResult>;
+        /**
+         * Delete all vectors in a namespace.
+         * @param {object} options - Delete all options.
+         * @returns {Promise<IDeleteVectorsResult>} The delete result.
+         */
+        deleteAll: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+        }) => Promise<import("./vector").IDeleteVectorsResult>;
+        /**
+         * List vector IDs.
+         * @param {object} options - List options.
+         * @returns {Promise<IListVectorsResult>} The list result.
+         */
+        listVectors: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+            prefix?: string;
+            limit?: number;
+            cursor?: string;
+        }) => Promise<import("./vector").IListVectorsResult>;
+        /**
+         * List all vector IDs (paginated).
+         * @param {object} options - List all options.
+         * @returns {Promise<string[]>} All vector IDs.
+         */
+        listAllVectors: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+            prefix?: string;
+        }) => Promise<string[]>;
+        /**
+         * List available namespaces.
+         * @param {object} options - Namespace list options.
+         * @returns {Promise<IListNamespacesResult>} The namespaces.
+         */
+        listNamespaces: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IListNamespacesResult>;
+        /**
+         * Delete a namespace.
+         * @param {object} options - Namespace delete options.
+         * @returns {Promise<void>} Resolves when deleted.
+         */
+        deleteNamespace: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace: string;
+        }) => Promise<void>;
+        /**
+         * Describe the current index.
+         * @param {object} options - Index describe options.
+         * @returns {Promise<IVectorIndexInfo>} The index info.
+         */
+        describeIndex: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IVectorIndexInfo>;
+        /**
+         * Get index statistics.
+         * @param {object} options - Stats options.
+         * @returns {Promise<IVectorIndexStats>} The index stats.
+         */
+        getStats: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IVectorIndexStats>;
+        /**
+         * Create a new index.
+         * @param {object} options - Create index options.
+         * @returns {Promise<ICreateIndexResult>} The create result.
+         */
+        createIndex: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            name: string;
+            dimensions: number;
+            metric?: import("./vector").DistanceMetric;
+            replicas?: number;
+            shards?: number;
+        }) => Promise<import("./vector").ICreateIndexResult>;
+        /**
+         * Delete an index.
+         * @param {object} options - Delete index options.
+         * @returns {Promise<IDeleteIndexResult>} The delete result.
+         */
+        deleteIndex: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            name: string;
+        }) => Promise<import("./vector").IDeleteIndexResult>;
+        /**
+         * List all indexes.
+         * @param {object} options - List indexes options.
+         * @returns {Promise<IVectorIndexInfo[]>} The list of indexes.
+         */
+        listIndexes: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").IVectorIndexInfo[]>;
+        /**
+         * Count vectors in the index.
+         * @param {object} options - Count options.
+         * @returns {Promise<number>} The vector count.
+         */
+        count: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            namespace?: string;
+        }) => Promise<number>;
+        /**
+         * Check if a vector exists.
+         * @param {object} options - Exists check options.
+         * @returns {Promise<boolean>} True if exists.
+         */
+        exists: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            id: string;
+            namespace?: string;
+        }) => Promise<boolean>;
+        /**
+         * Test connection to a vector database.
+         * @param {object} options - Test connection options.
+         * @returns {Promise<boolean>} True if connection is healthy.
+         */
+        testConnection: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<boolean>;
+        /**
+         * Check if a feature is supported.
+         * @param {object} options - Feature check options.
+         * @returns {Promise<boolean>} True if supported.
+         */
+        supportsFeature: (options: {
+            product: string;
+            env: string;
+            vector: string;
+            feature: import("./vector").VectorFeature;
+        }) => Promise<boolean>;
+        /**
+         * Get all supported features.
+         * @param {object} options - Get features options.
+         * @returns {Promise<VectorFeature[]>} The supported features.
+         */
+        getSupportedFeatures: (options: {
+            product: string;
+            env: string;
+            vector: string;
+        }) => Promise<import("./vector").VectorFeature[]>;
     };
     /**
      * Job-related operations for managing product jobs.
@@ -2212,7 +2557,7 @@ export default class Ductape implements IDuctape {
          * const secrets = await ductape.secrets.fetchAll();
          * secrets.forEach(s => console.log(s.key, s.description));
          */
-        fetchAll: () => Promise<ISecretMetadata[]>;
+        list: () => Promise<ISecretMetadata[]>;
         /**
          * Fetch a single secret with its decrypted value
          * @param key - The secret key
@@ -2307,7 +2652,9 @@ export default class Ductape implements IDuctape {
          * @param {IProductCache} data - The cache data.
          * @returns {Promise<void>} Resolves when the cache is created. Throws on error.
          */
-        create: (product: string, data: IProductCache) => Promise<void>;
+        create: (data: IProductCache & {
+            product: string;
+        }) => Promise<void>;
         /**
          * Fetches all caches for a product.
          * @param {string} product - The product tag.