@ductape/sdk 0.1.7 → 0.1.9

package/dist/cloud/types/cloud.types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Cloud provider connection and resource types (AWS, GCP, Azure).
+ */
+/** Supported cloud providers */
+export type CloudProvider = 'aws' | 'gcp' | 'azure';
+/** How the cloud account is linked to Ductape */
+export type CloudAuthMode = 'iam_role' | 'oauth' | 'service_principal' | 'workload_identity';
+/** Connection lifecycle status */
+export type CloudConnectionStatus = 'pending' | 'active' | 'error' | 'revoked';
+/** Scopes gate which resource types can be listed/imported */
+export type CloudConnectionScope = 'storage' | 'broker' | 'database' | 'graph' | 'vector' | 'cache';
+/** Workspace cloud connection record */
+export interface ICloudConnection {
+    id: string;
+    workspace_id: string;
+    provider: CloudProvider;
+    display_name: string;
+    account_identifier: string;
+    auth_mode: CloudAuthMode;
+    status: CloudConnectionStatus;
+    scopes: CloudConnectionScope[];
+    metadata?: Record<string, unknown>;
+    created_by?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface ICreateCloudConnectionInput {
+    provider: CloudProvider;
+    name: string;
+    scopes?: CloudConnectionScope[];
+    auth_mode?: CloudAuthMode;
+}
+/** Returned when a connection requires customer-side setup (e.g. IAM trust policy) */
+export interface ICloudConnectionSetup {
+    connection: ICloudConnection;
+    external_id?: string;
+    trust_policy?: Record<string, unknown> | string;
+    setup_instructions?: string;
+    setup_url?: string;
+}
+export interface ICompleteCloudConnectionInput {
+    /** AWS cross-account role */
+    role_arn?: string;
+    /** GCP project */
+    project_id?: string;
+    /** GCP service account email (optional when using WIF) */
+    service_account_email?: string;
+    /** Azure */
+    tenant_id?: string;
+    subscription_id?: string;
+    client_id?: string;
+}
+export interface IValidateCloudConnectionResult {
+    valid: boolean;
+    status: CloudConnectionStatus;
+    message?: string;
+    tested_at?: string;
+}
+/** Cloud resource kinds exposed by the connector */
+export type CloudResourceService = 's3' | 'sqs' | 'sns' | 'gcs' | 'pubsub' | 'blob' | 'servicebus' | 'rds' | 'neptune' | 'opensearch' | 'pinecone';
+export interface ICloudResource {
+    id: string;
+    name: string;
+    arn?: string;
+    region?: string;
+    service: CloudResourceService;
+    provider: CloudProvider;
+    metadata?: Record<string, unknown>;
+}
+export interface IListCloudResourcesInput {
+    connectionId: string;
+    service: CloudResourceService;
+    region?: string;
+    prefix?: string;
+    page?: number;
+    limit?: number;
+}
+export interface IListCloudResourcesResult {
+    resources: ICloudResource[];
+    total?: number;
+    page?: number;
+    limit?: number;
+    hasMore?: boolean;
+}
+/** Target Ductape component when importing or provisioning */
+export type CloudComponentType = 'storage' | 'messageBrokers' | 'databases' | 'graphs' | 'vectors' | 'caches';
+export interface IImportCloudResourceInput {
+    connectionId: string;
+    service: CloudResourceService;
+    resourceId: string;
+    componentType: CloudComponentType;
+    productTag: string;
+    componentTag: string;
+    envSlug: string;
+}
+export interface IProvisionCloudResourceInput {
+    connectionId: string;
+    service: CloudResourceService;
+    template: string;
+    componentType: CloudComponentType;
+    productTag: string;
+    componentTag: string;
+    envSlug: string;
+    params?: Record<string, unknown>;
+}
+/** Partial product component returned by the connector for builder persistence */
+export interface ICloudComponentDraft {
+    componentType: CloudComponentType;
+    tag: string;
+    name?: string;
+    description?: string;
+    draft: Record<string, unknown>;
+}
+export interface IImportCloudResourceResult {
+    resource: ICloudResource;
+    componentDraft: ICloudComponentDraft;
+}
+export interface IProvisionCloudResourceResult extends IImportCloudResourceResult {
+    provisioned: boolean;
+}
+/** Runtime short-lived credentials (proxy / connector broker) */
+export interface ICloudRuntimeCredentialsInput {
+    connectionId: string;
+    productTag: string;
+    componentTag: string;
+    envSlug: string;
+    purpose?: 'runtime' | 'validate';
+}
+export interface ICloudRuntimeCredentials {
+    provider: CloudProvider;
+    expiresAt: string;
+    credentials: Record<string, unknown>;
+}
+/** Optional fields on storage/broker configs when linked via cloud connection */
+export type ComponentCloudAuthMode = 'manual' | 'cloud_connection';
+export interface ICloudLinkedComponentFields {
+    authMode?: ComponentCloudAuthMode;
+    cloudConnectionId?: string;
+    roleArn?: string;
+}

package/dist/cloud/types/cloud.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Cloud provider connection and resource types (AWS, GCP, Azure).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=cloud.types.js.map

package/dist/cloud/types/cloud.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud.types.js","sourceRoot":"","sources":["../../../src/cloud/types/cloud.types.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/cloud/types/index.d.ts

@@ -0,0 +1 @@
+export * from './cloud.types';

package/dist/cloud/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cloud.types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cloud/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/cloud/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA8B"}

package/dist/database/databases.service.d.ts

@@ -39,6 +39,20 @@ export interface IDatabaseServiceConfig {
     private_key: string;
     /** Optional Redis client for caching */
     redis_client?: IORedisClient;
+    /** Default product tag when omitted from connect/query payloads */
+    default_product?: string;
+    /** Default environment slug when omitted from connect/query payloads */
+    default_env?: string;
+}
+/**
+ * Normalized schema snapshot for a database connection context.
+ * Used by payload/metadata generation to get full table+column+index context in one call.
+ */
+export interface IDatabaseSchemaSnapshot {
+    database: string;
+    env: string;
+    tables: ITableSchema[];
+    generatedAt: string;
 }
 /**
  * Main Database Service class
@@ -70,6 +84,7 @@ export declare class DatabaseService {
     private cacheConfigCache;
     /** In-flight connect() promises per contextKey to deduplicate concurrent connects and avoid duplicate logs */
     private connectPromises;
+    private runtimeDefaults;
     /**
      * Create a new DatabaseService instance
      * @param config - Optional configuration for authentication and workspace context
@@ -230,6 +245,8 @@ export declare class DatabaseService {
      * - All parts are automatically capitalized
      */
     private generateDbSecretKey;
+    private resolveRuntimeProductEnv;
+    private mergeConnectionConfig;
     /**
      * Connect to a database
      *
@@ -746,6 +763,19 @@ export declare class DatabaseService {
      * );
      */
     getIndexStatistics(connectionConfig: IConnectionConfig, tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
+    /**
+     * Get a normalized schema snapshot for the given database/env context.
+     *
+     * @example
+     * const snapshot = await ductape.database.getSchemaSnapshot({
+     *   env: 'prd',
+     *   product: 'my-product',
+     *   database: 'main-db',
+     * });
+     */
+    getSchemaSnapshot(connectionConfig: IConnectionConfig, options?: {
+        includeTables?: string[];
+    }): Promise<IDatabaseSchemaSnapshot>;
     /**
      * Run a migration
      *

package/dist/database/databases.service.js

@@ -67,6 +67,7 @@ const logs_service_1 = __importDefault(require("../logs/logs.service"));
 const logs_types_1 = require("../logs/logs.types");
 const processor_utils_1 = require("../processor/utils/processor.utils");
 const secrets_1 = require("../secrets");
+const cloud_runtime_util_1 = require("../cloud/cloud-runtime.util");
 /** Module-level: last time we logged connect initiated/success/failed per key, to avoid duplicate logs across multiple DatabaseService instances */
 const lastConnectLogAt = new Map();
 const CONNECT_LOG_DEBOUNCE_MS = 15000;
@@ -109,11 +110,18 @@ class DatabaseService {
         this.cacheConfigCache = new Map();
         /** In-flight connect() promises per contextKey to deduplicate concurrent connects and avoid duplicate logs */
         this.connectPromises = new Map();
+        this.runtimeDefaults = {};
         this.config = config || null;
         this.adapterFactory = new adapter_factory_1.AdapterFactory();
         this.transactionManager = new transaction_manager_1.TransactionManager();
         this.actionManager = new action_manager_1.ActionManager(this);
         this._privateKey = (config === null || config === void 0 ? void 0 : config.private_key) || '';
+        if ((config === null || config === void 0 ? void 0 : config.default_product) || (config === null || config === void 0 ? void 0 : config.default_env)) {
+            this.runtimeDefaults = {
+                default_product: config.default_product,
+                default_env: config.default_env,
+            };
+        }
         // Initialize CacheManager (Redis is optional - Tier 1 internal cache and Tier 3 remote cache always work)
         if ((config === null || config === void 0 ? void 0 : config.workspace_id) && (config === null || config === void 0 ? void 0 : config.public_key) && (config === null || config === void 0 ? void 0 : config.user_id) && (config === null || config === void 0 ? void 0 : config.token)) {
             this.cacheManager = new cache_manager_1.CacheManager({
@@ -563,6 +571,8 @@ class DatabaseService {
                 connected: false,
                 name: config.name,
                 description: config.description,
+                authMode: envConfig.authMode,
+                cloudConnectionId: envConfig.cloudConnectionId,
             });
         }
     }
@@ -594,6 +604,20 @@ class DatabaseService {
         }
         return `DB_${sanitize(productKey)}_${sanitize(assetTag)}_${sanitize(env)}_URL`;
     }
+    resolveRuntimeProductEnv(fields) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        return {
+            product: (_d = (_c = (_a = fields.product) !== null && _a !== void 0 ? _a : (_b = this.currentContext) === null || _b === void 0 ? void 0 : _b.product) !== null && _c !== void 0 ? _c : this.runtimeDefaults.default_product) !== null && _d !== void 0 ? _d : (_e = this.config) === null || _e === void 0 ? void 0 : _e.default_product,
+            env: (_j = (_h = (_f = fields.env) !== null && _f !== void 0 ? _f : (_g = this.currentContext) === null || _g === void 0 ? void 0 : _g.env) !== null && _h !== void 0 ? _h : this.runtimeDefaults.default_env) !== null && _j !== void 0 ? _j : (_k = this.config) === null || _k === void 0 ? void 0 : _k.default_env,
+        };
+    }
+    mergeConnectionConfig(config) {
+        const { product, env } = this.resolveRuntimeProductEnv(config);
+        if (!(product === null || product === void 0 ? void 0 : product.trim()) || !(env === null || env === void 0 ? void 0 : env.trim())) {
+            throw new database_error_1.DatabaseError('product and env are required. Pass them in connect() or set both on the Ductape constructor.', enums_1.DatabaseErrorType.VALIDATION_ERROR);
+        }
+        return Object.assign(Object.assign({}, config), { product: product.trim(), env: env.trim() });
+    }
     /**
      * Connect to a database
      *
@@ -613,6 +637,7 @@ class DatabaseService {
      */
     async connect(config) {
         var _a, _b, _c;
+        config = this.mergeConnectionConfig(config);
         const process_id = (0, processor_utils_1.generateObjectId)();
         const start = Date.now();
         const contextKey = this.buildContextKey(config.database, config.env);
@@ -669,6 +694,8 @@ class DatabaseService {
                     slug: e.slug,
                     connection_url: e.connection_url,
                     description: e.description,
+                    authMode: e.authMode,
+                    cloudConnectionId: e.cloudConnectionId,
                 })),
             });
             adapter = this.adapters.get(contextKey);
@@ -754,6 +781,8 @@ class DatabaseService {
                     slug: e.slug,
                     connection_url: e.connection_url,
                     description: e.description,
+                    authMode: e.authMode,
+                    cloudConnectionId: e.cloudConnectionId,
                 })),
             });
             adapter = this.adapters.get(contextKey);
@@ -801,17 +830,38 @@ class DatabaseService {
             this.logService.add(Object.assign(Object.assign({}, baseLogs), { start, message: 'Database connect - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
         }
         try {
-            // Resolve secret reference in connection URL if needed
             let connectionUrl = context.connectionUrl;
-            const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
-            if (secretCheck.isSecret) {
-                const secretsService = (0, secrets_1.getSecretsService)();
-                if (secretsService) {
-                    const resolved = await secretsService.resolve(connectionUrl, { env: config.env });
-                    connectionUrl = resolved.value;
-                }
-                else {
-                    throw new database_error_1.DatabaseError(`Connection URL contains secret reference but secrets service is not initialized.`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
+            if (this.config && (context.authMode === 'cloud_connection' || (0, secrets_1.isSecretReference)(connectionUrl).isSecret)) {
+                const resolvedEnv = await (0, cloud_runtime_util_1.resolveCloudLinkedEnvConfig)({
+                    connection_url: context.connectionUrl,
+                    authMode: context.authMode,
+                    cloudConnectionId: context.cloudConnectionId,
+                }, {
+                    environment: this.config.env_type,
+                    auth: {
+                        token: this.config.token,
+                        public_key: this.config.public_key,
+                        user_id: this.config.user_id,
+                        workspace_id: this.config.workspace_id,
+                        access_key: this.config.access_key,
+                    },
+                    productTag: config.product || '',
+                    componentTag: config.database,
+                    envSlug: config.env,
+                });
+                connectionUrl = String(resolvedEnv.connection_url || connectionUrl);
+            }
+            else {
+                const secretCheck = (0, secrets_1.isSecretReference)(connectionUrl);
+                if (secretCheck.isSecret) {
+                    const secretsService = (0, secrets_1.getSecretsService)();
+                    if (secretsService) {
+                        const resolved = await secretsService.resolve(connectionUrl, { env: config.env });
+                        connectionUrl = resolved.value;
+                    }
+                    else {
+                        throw new database_error_1.DatabaseError(`Connection URL contains secret reference but secrets service is not initialized.`, enums_1.DatabaseErrorType.CONNECTION_ERROR);
+                    }
                 }
             }
             await adapter.connect({
@@ -1977,6 +2027,32 @@ class DatabaseService {
         const adapter = this.getAdapter(connectionConfig);
         return adapter.getIndexStatistics(tableName, indexName);
     }
+    /**
+     * Get a normalized schema snapshot for the given database/env context.
+     *
+     * @example
+     * const snapshot = await ductape.database.getSchemaSnapshot({
+     *   env: 'prd',
+     *   product: 'my-product',
+     *   database: 'main-db',
+     * });
+     */
+    async getSchemaSnapshot(connectionConfig, options) {
+        var _a;
+        await this.ensureAdapterFor(connectionConfig);
+        const adapter = this.getAdapter(connectionConfig);
+        const tableNames = ((_a = options === null || options === void 0 ? void 0 : options.includeTables) === null || _a === void 0 ? void 0 : _a.length) ? options.includeTables : await adapter.listTables();
+        const tables = [];
+        for (const tableName of tableNames) {
+            tables.push(await adapter.getTableSchema(tableName));
+        }
+        return {
+            database: connectionConfig.database,
+            env: connectionConfig.env,
+            tables,
+            generatedAt: new Date().toISOString(),
+        };
+    }
     // ==================== MIGRATION OPERATIONS ====================
     /**
      * Run a migration