@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/cache/index.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Ductape Cache Module
+ *
+ * Provides a unified API for managing remote cache values including
+ * fetching, setting, and deleting cache entries.
+ *
+ * @example
+ * ```ts
+ * import { CacheService } from '@ductape/sdk';
+ *
+ * const cache = new CacheService({
+ *   workspace_id: 'your-workspace-id',
+ *   public_key: 'your-public-key',
+ *   user_id: 'your-user-id',
+ *   token: 'your-token',
+ *   env_type: 'prd',
+ * });
+ *
+ * // Fetch cache values
+ * const values = await cache.fetchValues({
+ *   product: 'my-product',
+ *   cache: 'user-cache',
+ *   page: 1,
+ *   limit: 20,
+ * });
+ *
+ * // Get dashboard metrics
+ * const dashboard = await cache.fetchDashboard({
+ *   product: 'my-product',
+ *   cache: 'user-cache',
+ * });
+ *
+ * // Get a specific value
+ * const value = await cache.get({ key: 'user:123' });
+ *
+ * // Set a value
+ * await cache.set({
+ *   product: 'my-product',
+ *   cache: 'user-cache',
+ *   key: 'user:123',
+ *   value: JSON.stringify({ name: 'John' }),
+ * });
+ *
+ * // Delete a value
+ * await cache.delete({ key: 'user:123' });
+ * ```
+ */
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = exports.CacheServiceDefault = exports.CacheError = exports.CacheService = void 0;
+// Main service
+var cache_service_1 = require("./cache.service");
+Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
+Object.defineProperty(exports, "CacheError", { enumerable: true, get: function () { return cache_service_1.CacheError; } });
+var cache_service_2 = require("./cache.service");
+Object.defineProperty(exports, "CacheServiceDefault", { enumerable: true, get: function () { return __importDefault(cache_service_2).default; } });
+// Cache Manager for executor services
+var cache_manager_1 = require("./cache.manager");
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return cache_manager_1.CacheManager; } });
+// Types
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;;;;;;;;;;;;;;;;;;;;AAEH,eAAe;AACf,iDAA2D;AAAlD,6GAAA,YAAY,OAAA;AAAE,2GAAA,UAAU,OAAA;AACjC,iDAAiE;AAAxD,qIAAA,OAAO,OAAuB;AAEvC,sCAAsC;AACtC,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AAGrB,QAAQ;AACR,0CAAwB"}

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

@@ -0,0 +1,106 @@
+/**
+ * Cache Types
+ */
+/**
+ * Cache service configuration
+ */
+export interface ICacheServiceConfig {
+    workspace_id: string;
+    public_key: string;
+    user_id: string;
+    token: string;
+    env_type: string;
+}
+/**
+ * Cache value entry
+ */
+export interface ICacheValue {
+    _id?: string;
+    key: string;
+    value: string;
+    cache_tag: string;
+    product_tag: string;
+    component_tag: string;
+    component_type: string;
+    expiry?: Date;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+/**
+ * Options for fetching paginated cache values
+ */
+export interface IFetchCacheValuesOptions {
+    product: string;
+    cache: string;
+    env?: string;
+    page?: number;
+    limit?: number;
+}
+/**
+ * Result for paginated cache values
+ */
+export interface IFetchCacheValuesResult {
+    values: ICacheValue[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+/**
+ * Options for fetching cache dashboard
+ */
+export interface IFetchCacheDashboardOptions {
+    product: string;
+    cache: string;
+    env?: string;
+}
+/**
+ * Cache dashboard metrics
+ */
+export interface ICacheDashboardMetrics {
+    totalValues: number;
+    activeValues: number;
+    expiredValues: number;
+    totalSize: number;
+}
+/**
+ * Options for clearing a cache value
+ */
+export interface IClearCacheValueOptions {
+    key: string;
+}
+/**
+ * Options for clearing multiple cache values
+ */
+export interface IClearCacheValuesOptions {
+    product: string;
+    cache: string;
+    env?: string;
+}
+/**
+ * Result for clearing multiple cache values
+ */
+export interface IClearCacheValuesResult {
+    cleared: number;
+}
+export type IDeleteCacheValueOptions = IClearCacheValueOptions;
+export type IDeleteCacheValuesOptions = IClearCacheValuesOptions;
+export type IDeleteCacheValuesResult = IClearCacheValuesResult;
+/**
+ * Options for setting a cache value
+ */
+export interface ISetCacheValueOptions {
+    product: string;
+    cache: string;
+    key: string;
+    value: string;
+    componentTag?: string;
+    componentType?: string;
+    expiry?: Date;
+}
+/**
+ * Options for getting a cache value
+ */
+export interface IGetCacheValueOptions {
+    key: string;
+}

package/dist/cache/types/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Cache Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

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

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

package/dist/clients/pricing.client.d.ts

@@ -0,0 +1,3 @@
+import { AxiosInstance } from "axios";
+import { EnvType } from "../types";
+export declare const pricingClient: (auth: string, contentType: string, environment: EnvType) => AxiosInstance;

package/dist/clients/pricing.client.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pricingClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const urls_1 = require("../api/urls");
+const CancelToken = axios_1.default.CancelToken;
+const source = CancelToken.source();
+const requestInterceptor = async (config) => {
+    config.cancelToken = source.token;
+    return config;
+};
+let instance;
+const pricingClient = (auth, contentType, environment) => {
+    if (instance)
+        return instance;
+    instance = axios_1.default.create({
+        baseURL: (0, urls_1.getUrlForEnvironment)(environment, 'pricing'),
+        timeout: 15000,
+        headers: {
+            'Content-Type': contentType,
+            Authorization: auth
+        },
+        withCredentials: false
+    });
+    // @ts-ignore
+    instance.interceptors.request.use(requestInterceptor);
+    return instance;
+};
+exports.pricingClient = pricingClient;
+//# sourceMappingURL=pricing.client.js.map

package/dist/clients/pricing.client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.client.js","sourceRoot":"","sources":["../../src/clients/pricing.client.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0D;AAC1D,sCAAmD;AAGnD,MAAM,WAAW,GAAG,eAAK,CAAC,WAAW,CAAC;AACtC,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC;AACpC,MAAM,kBAAkB,GAAG,KAAK,EAAE,MAAqC,EAAE,EAAE;IACzE,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC;IAClC,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AACF,IAAI,QAAuB,CAAC;AAErB,MAAM,aAAa,GAAG,CAAC,IAAY,EAAE,WAAmB,EAAE,WAAoB,EAAE,EAAE;IACvF,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,QAAQ,GAAG,eAAK,CAAC,MAAM,CAAC;QACtB,OAAO,EAAE,IAAA,2BAAoB,EAAC,WAAW,EAAE,SAAS,CAAC;QACrD,OAAO,EAAE,KAAK;QACd,OAAO,EAAE;YACP,cAAc,EAAE,WAAW;YAC3B,aAAa,EAAE,IAAI;SACpB;QACD,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;IAEH,aAAa;IACb,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IACtD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAfW,QAAA,aAAa,iBAexB"}

package/dist/database/actions/action-manager.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Action Manager
+ *
+ * Manages reusable database actions (query templates).
+ * Actions allow defining common database operations that can be
+ * executed with different input parameters.
+ *
+ * Uses ProductBuilder for persistence to the backend.
+ */
+import { DatabaseActionType } from '../types/enums';
+import { IActionDefinition, IActionTemplate, IActionCreateOptions, IActionUpdateOptions, IActionExecuteOptions, IPlaceholder, IParsedTemplate } from '../types/action.interface';
+import { IWhereClause } from '../types/query.interface';
+/**
+ * DatabaseService reference type (to avoid circular imports)
+ */
+interface IDatabaseServiceRef {
+    getConfig(): {
+        workspace_id: string;
+        public_key: string;
+        user_id: string;
+        token: string;
+        env_type: string;
+    } | null;
+}
+/**
+ * Action Manager for managing reusable database actions
+ * Uses ProductBuilder for persistent storage
+ */
+export declare class ActionManager {
+    private databaseService;
+    private productBuilders;
+    constructor(databaseService: IDatabaseServiceRef);
+    /**
+     * Create a new ProductBuilder instance
+     */
+    private createNewProductBuilder;
+    /**
+     * Get or create a ProductBuilder instance for the given product tag
+     */
+    private getProductBuilder;
+    /**
+     * Create a new database action
+     * @param options Action creation options
+     */
+    create(options: IActionCreateOptions): Promise<void>;
+    /**
+     * Update an existing database action
+     * @param options Action update options
+     */
+    update(options: IActionUpdateOptions): Promise<void>;
+    /**
+     * Fetch a specific database action
+     * @param tag Action tag in format: product:database:action
+     * @returns Action definition or null
+     */
+    fetch(tag: string): Promise<IActionDefinition | null>;
+    /**
+     * Fetch all database actions for a database
+     * @param tag Database tag in format: product:database
+     * @returns Array of action definitions
+     */
+    fetchAll(tag: string): Promise<IActionDefinition[]>;
+    /**
+     * Delete a database action
+     * @param tag Action tag in format: product:database:action
+     */
+    delete(tag: string): Promise<void>;
+    /**
+     * Execute a database action
+     *
+     * Note: Action execution is handled through the ProcessorService.
+     * This method validates the action exists and returns the action definition
+     * for the caller to execute through the appropriate channel.
+     *
+     * @param options Execution options
+     * @returns Action result
+     */
+    execute<T = any>(options: IActionExecuteOptions): Promise<T>;
+    /**
+     * Parse a template and extract placeholders
+     * @param template Action template
+     * @returns Parsed template with placeholder info
+     */
+    parseTemplate(template: IActionTemplate): IParsedTemplate;
+    /**
+     * Extract all placeholders from a template
+     * @param template Action template
+     * @returns Array of placeholder definitions
+     */
+    extractPlaceholders(template: IActionTemplate): IPlaceholder[];
+    /**
+     * Validate input against placeholder requirements
+     * @param template Action template
+     * @param input Input values
+     * @returns True if valid
+     */
+    validateInput(template: IActionTemplate, input: Record<string, any>): boolean;
+    /**
+     * Parse action tag into components
+     * Supports formats:
+     * - product:database:action
+     * - database:action (uses default product)
+     */
+    private parseActionTag;
+    /**
+     * Map internal operation type to ProductDatabaseActionTypes
+     */
+    private mapOperationType;
+    /**
+     * Convert IProductDatabaseAction to IActionDefinition
+     */
+    private convertToActionDefinition;
+    /**
+     * Map ProductDatabaseActionTypes to DatabaseActionType
+     */
+    private mapProductActionType;
+    /**
+     * Parse stored template (may be string or object)
+     */
+    private parseStoredTemplate;
+    /**
+     * Resolve template placeholders with input values
+     */
+    private resolveTemplate;
+    private resolveObject;
+    private resolvePlaceholdersInString;
+}
+/**
+ * Action Builder for fluent action creation
+ */
+export declare class ActionBuilder {
+    private options;
+    /**
+     * Set action name
+     */
+    name(name: string): this;
+    /**
+     * Set action tag
+     */
+    tag(tag: string): this;
+    /**
+     * Set table name
+     */
+    table(tableName: string): this;
+    /**
+     * Set operation type
+     */
+    operation(operation: DatabaseActionType | string): this;
+    /**
+     * Set description
+     */
+    description(description: string): this;
+    /**
+     * Set template
+     */
+    template(template: IActionTemplate): this;
+    /**
+     * Set filter template
+     */
+    filter(filterTemplate: IWhereClause): this;
+    /**
+     * Build the action options
+     */
+    build(): IActionCreateOptions;
+}
+/**
+ * Create a new action builder
+ */
+export declare function createAction(): ActionBuilder;
+export {};