@ductape/sdk 0.0.4-v99 → 0.0.5

package/dist/test/test.database.postgres.js

@@ -1,412 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const database_1 = require("../database");
-const index_1 = __importDefault(require("./index"));
-/**
- * PostgreSQL Database Tests
- *
- * Comprehensive tests for PostgreSQL database operations:
- * - Connection management
- * - Schema operations (create, alter, drop tables)
- * - CRUD operations (insert, query, update, delete)
- * - Aggregations (count, sum, avg, min, max)
- * - Transactions
- * - Pre-save operations (trim, hash, encrypt, normalize)
- * - Raw queries
- * - Migrations
- */
-const { databases } = index_1.default;
-databases.create({
-    product: 'ductape:rematch',
-    name: 'PostgresDB',
-    tag: 'postgres-db',
-    type: database_1.DatabaseType.POSTGRESQL,
-    envs: [{
-            slug: 'prd',
-            connection_url: 'postgres://avnadmin:AVNS_EslAIqyyBg9876k5_NQ@pg-399355e6-ductapetech-postgres.e.aivencloud.com:24999/rematch-prd?sslmode=require'
-        }, {
-            slug: 'dev',
-            connection_url: 'postgres://avnadmin:AVNS_EslAIqyyBg9876k5_NQ@pg-399355e6-ductapetech-postgres.e.aivencloud.com:24999/rematch-dev?sslmode=require'
-        }]
-}).then(() => {
-    console.log('PostgreSQL database created');
-});
-// Start timing
-const startTime = performance.now();
-console.log(`[${new Date().toISOString()}] Starting PostgreSQL database operations...`);
-/*databases
-  .connect({
-    env: 'prd',
-    product: 'ductape:rematch',
-    database: 'postgres-db', // Your PostgreSQL database tag
-  })
-  .then(async (connection) => {
-    const connectTime = performance.now();
-    console.log(`[TIMING] Connect: ${(connectTime - startTime).toFixed(2)}ms`);
-    console.log('PostgreSQL connection established:', connection);
-
-    // ==================== SCHEMA OPERATIONS ====================
-
-    console.log('\n--- Schema Operations ---');
-
-    // List existing tables
-    const listStart = performance.now();
-    const tables = await databases.schema.list();
-    console.log(`[TIMING] Schema list: ${(performance.now() - listStart).toFixed(2)}ms`);
-    console.log('Existing tables:', tables);
-
-    // Drop test table if exists
-    if (tables.includes('test_users')) {
-      console.log('Dropping existing "test_users" table...');
-      await databases.schema.drop('test_users');
-    }
-
-    // Create table with PostgreSQL-specific types
-    console.log('Creating table "test_users"...');
-    const createStart = performance.now();
-    await databases.schema.create('test_users', {
-      id: { type: 'serial', primaryKey: true },
-      uuid: { type: 'uuid', default: 'gen_random_uuid()' },
-      name: { type: 'varchar(255)', nullable: false },
-      email: { type: 'varchar(255)', unique: true, nullable: false },
-      password: { type: 'varchar(255)' },
-      age: { type: 'integer' },
-      balance: { type: 'decimal(10,2)', default: '0.00' },
-      metadata: { type: 'jsonb' },
-      tags: { type: 'text[]' },
-      active: { type: 'boolean', default: true },
-      created_at: { type: 'timestamp', default: 'now()' },
-      updated_at: { type: 'timestamp', default: 'now()' },
-    });
-    console.log(`[TIMING] Schema create: ${(performance.now() - createStart).toFixed(2)}ms`);
-
-    // Get table schema
-    const schemaStart = performance.now();
-    const tableSchema = await databases.schema.describe('test_users');
-    console.log(`[TIMING] Schema describe: ${(performance.now() - schemaStart).toFixed(2)}ms`);
-    console.log('Table schema:', JSON.stringify(tableSchema, null, 2));
-
-    // Create index
-    console.log('Creating index on email...');
-    const indexStart = performance.now();
-    await databases.schema.createIndex('test_users', {
-      name: 'idx_test_users_email',
-      columns: ['email'],
-      unique: true,
-    });
-    console.log(`[TIMING] Create index: ${(performance.now() - indexStart).toFixed(2)}ms`);
-
-    // ==================== INSERT OPERATIONS ====================
-
-    console.log('\n--- Insert Operations ---');
-
-    // Generate unique test data
-    const timestamp = Date.now();
-    const testEmail = `test.user.${timestamp}@example.com`;
-
-    // Insert with pre-save operations
-    console.log('Inserting user with pre-save operations...');
-    const insertStart = performance.now();
-    const insertResult = await databases.insert({
-      table: 'test_users',
-      data: {
-        name: '  John Doe  ',
-        email: testEmail.toUpperCase(),
-        password: 'password123',
-        age: 30,
-        balance: 1000.50,
-        metadata: { role: 'admin', preferences: { theme: 'dark' } },
-        tags: ['developer', 'nodejs'],
-      },
-      returning: true,
-      preSave: [
-        PreSave.trim('name'),
-        PreSave.normalizeEmail('email'),
-        PreSave.hash('password', { algorithm: 'sha256' }),
-      ],
-    });
-    console.log(`[TIMING] Insert: ${(performance.now() - insertStart).toFixed(2)}ms`);
-    console.log('Inserted user:', JSON.stringify(insertResult, null, 2));
-
-    // Bulk insert
-    console.log('Bulk inserting users...');
-    const bulkStart = performance.now();
-    const bulkResult = await databases.insert({
-      table: 'test_users',
-      data: [
-        { name: 'Jane Smith', email: `jane.${timestamp}@example.com`, age: 25, balance: 500.00 },
-        { name: 'Bob Wilson', email: `bob.${timestamp}@example.com`, age: 35, balance: 1500.75 },
-        { name: 'Alice Brown', email: `alice.${timestamp}@example.com`, age: 28, balance: 750.25 },
-      ],
-      returning: true,
-    });
-    console.log(`[TIMING] Bulk insert: ${(performance.now() - bulkStart).toFixed(2)}ms`);
-    console.log(`Inserted ${bulkResult.count} users`);
-
-    // Upsert (ON CONFLICT)
-    console.log('Testing upsert (ON CONFLICT)...');
-    const upsertStart = performance.now();
-    const upsertResult = await databases.insert({
-      table: 'test_users',
-      data: { name: 'John Doe Updated', email: testEmail, age: 31 },
-      onConflict: {
-        columns: ['email'],
-        action: 'update',
-        update: ['name', 'age'],
-      },
-      returning: true,
-    });
-    console.log(`[TIMING] Upsert: ${(performance.now() - upsertStart).toFixed(2)}ms`);
-    console.log('Upsert result:', JSON.stringify(upsertResult, null, 2));
-
-    // ==================== QUERY OPERATIONS ====================
-
-    console.log('\n--- Query Operations ---');
-
-    // Simple query
-    console.log('Querying all users...');
-    const queryStart = performance.now();
-    const allUsers = await databases.query({
-      table: 'test_users',
-      orderBy: [{ column: 'created_at', order: 'DESC' }],
-    });
-    console.log(`[TIMING] Query all: ${(performance.now() - queryStart).toFixed(2)}ms`);
-    console.log(`Found ${allUsers.data.length} users`);
-
-    // Query with where clause
-    console.log('Querying users with age > 27...');
-    const whereStart = performance.now();
-    const filteredUsers = await databases.query({
-      table: 'test_users',
-      where: { age: Operators.gt(27) },
-      select: ['id', 'name', 'email', 'age'],
-    });
-    console.log(`[TIMING] Query with where: ${(performance.now() - whereStart).toFixed(2)}ms`);
-    console.log('Filtered users:', JSON.stringify(filteredUsers.data, null, 2));
-
-    // Query with complex operators
-    console.log('Complex query with multiple conditions...');
-    const complexStart = performance.now();
-    const complexQuery = await databases.query({
-      table: 'test_users',
-      where: {
-        $and: [
-          { age: Operators.gte(25) },
-          { balance: Operators.lt(1000) },
-          { active: true },
-        ],
-      },
-      orderBy: [{ column: 'balance', order: 'DESC' }],
-      limit: 10,
-    });
-    console.log(`[TIMING] Complex query: ${(performance.now() - complexStart).toFixed(2)}ms`);
-    console.log('Complex query results:', complexQuery.data.length);
-
-    // Query with LIKE
-    console.log('Query with LIKE operator...');
-    const likeStart = performance.now();
-    const likeQuery = await databases.query({
-      table: 'test_users',
-      where: { email: Operators.like('%example.com') },
-    });
-    console.log(`[TIMING] LIKE query: ${(performance.now() - likeStart).toFixed(2)}ms`);
-    console.log('LIKE query results:', likeQuery.data.length);
-
-    // Query with IN
-    console.log('Query with IN operator...');
-    const inStart = performance.now();
-    const inQuery = await databases.query({
-      table: 'test_users',
-      where: { age: Operators.in([25, 30, 35]) },
-    });
-    console.log(`[TIMING] IN query: ${(performance.now() - inStart).toFixed(2)}ms`);
-    console.log('IN query results:', inQuery.data.length);
-
-    // ==================== UPDATE OPERATIONS ====================
-
-    console.log('\n--- Update Operations ---');
-
-    // Simple update
-    console.log('Updating user balance...');
-    const updateStart = performance.now();
-    const updateResult = await databases.update({
-      table: 'test_users',
-      data: { balance: 2000.00, updated_at: new Date() },
-      where: { email: testEmail },
-      returning: true,
-    });
-    console.log(`[TIMING] Update: ${(performance.now() - updateStart).toFixed(2)}ms`);
-    console.log('Update result:', JSON.stringify(updateResult, null, 2));
-
-    // Increment update
-    console.log('Incrementing all balances by 100...');
-    const incStart = performance.now();
-    const incResult = await databases.update({
-      table: 'test_users',
-      data: { balance: Operators.increment(100) },
-      where: { active: true },
-    });
-    console.log(`[TIMING] Increment update: ${(performance.now() - incStart).toFixed(2)}ms`);
-    console.log(`Updated ${incResult.count} rows`);
-
-    // ==================== AGGREGATION OPERATIONS ====================
-
-    console.log('\n--- Aggregation Operations ---');
-
-    // Count
-    const countStart = performance.now();
-    const count = await databases.count({ table: 'test_users' });
-    console.log(`[TIMING] Count: ${(performance.now() - countStart).toFixed(2)}ms`);
-    console.log('Total users:', count);
-
-    // Count with where
-    const countWhereStart = performance.now();
-    const activeCount = await databases.count({
-      table: 'test_users',
-      where: { active: true },
-    });
-    console.log(`[TIMING] Count with where: ${(performance.now() - countWhereStart).toFixed(2)}ms`);
-    console.log('Active users:', activeCount);
-
-    // Sum
-    const sumStart = performance.now();
-    const totalBalance = await databases.sum({
-      table: 'test_users',
-      column: 'balance',
-    });
-    console.log(`[TIMING] Sum: ${(performance.now() - sumStart).toFixed(2)}ms`);
-    console.log('Total balance:', totalBalance);
-
-    // Average
-    const avgStart = performance.now();
-    const avgAge = await databases.avg({
-      table: 'test_users',
-      column: 'age',
-    });
-    console.log(`[TIMING] Avg: ${(performance.now() - avgStart).toFixed(2)}ms`);
-    console.log('Average age:', avgAge);
-
-    // Min/Max
-    const minStart = performance.now();
-    const minAge = await databases.min({ table: 'test_users', column: 'age' });
-    console.log(`[TIMING] Min: ${(performance.now() - minStart).toFixed(2)}ms`);
-    console.log('Minimum age:', minAge);
-
-    const maxStart = performance.now();
-    const maxBalance = await databases.max({ table: 'test_users', column: 'balance' });
-    console.log(`[TIMING] Max: ${(performance.now() - maxStart).toFixed(2)}ms`);
-    console.log('Maximum balance:', maxBalance);
-
-    // Group by aggregation
-    const groupStart = performance.now();
-    const groupResult = await databases.aggregate({
-      table: 'test_users',
-      operations: [
-        { type: 'count', alias: 'user_count' },
-        { type: 'avg', column: 'balance', alias: 'avg_balance' },
-      ],
-      groupBy: ['active'],
-    });
-    console.log(`[TIMING] Group by: ${(performance.now() - groupStart).toFixed(2)}ms`);
-    console.log('Group by results:', JSON.stringify(groupResult, null, 2));
-
-    // ==================== RAW QUERIES ====================
-
-    console.log('\n--- Raw Queries ---');
-
-    // PostgreSQL-specific raw query
-    const rawStart = performance.now();
-    const rawResult = await databases.raw({
-      query: `
-        SELECT
-          name,
-          email,
-          age,
-          balance,
-          CASE
-            WHEN balance > 1000 THEN 'high'
-            WHEN balance > 500 THEN 'medium'
-            ELSE 'low'
-          END as balance_tier
-        FROM test_users
-        WHERE age > $1
-        ORDER BY balance DESC
-      `,
-      params: [25],
-    });
-    console.log(`[TIMING] Raw query: ${(performance.now() - rawStart).toFixed(2)}ms`);
-    console.log('Raw query results:', JSON.stringify(rawResult.data, null, 2));
-
-    // ==================== TRANSACTION ====================
-
-    console.log('\n--- Transaction ---');
-
-    const txStart = performance.now();
-    try {
-      const tx = await databases.beginTransaction({ isolationLevel: 'serializable' });
-
-      // Insert within transaction
-      await databases.insert({
-        table: 'test_users',
-        data: { name: 'TX User', email: `tx.${timestamp}@example.com`, age: 40 },
-        transaction: tx,
-      });
-
-      // Update within transaction
-      await databases.update({
-        table: 'test_users',
-        data: { balance: Operators.increment(50) },
-        where: { email: `tx.${timestamp}@example.com` },
-        transaction: tx,
-      });
-
-      // Commit
-      await tx.commit();
-      console.log(`[TIMING] Transaction: ${(performance.now() - txStart).toFixed(2)}ms`);
-      console.log('Transaction committed successfully');
-    } catch (error) {
-      console.log('Transaction error:', error);
-    }
-
-    // ==================== DELETE OPERATIONS ====================
-
-    console.log('\n--- Delete Operations ---');
-
-    // Delete specific record
-    const deleteStart = performance.now();
-    const deleteResult = await databases.delete({
-      table: 'test_users',
-      where: { email: `tx.${timestamp}@example.com` },
-      returning: true,
-    });
-    console.log(`[TIMING] Delete: ${(performance.now() - deleteStart).toFixed(2)}ms`);
-    console.log(`Deleted ${deleteResult.count} rows`);
-
-    // ==================== CLEANUP ====================
-
-    console.log('\n--- Cleanup ---');
-    const cleanupStart = performance.now();
-
-    // Drop index
-    await databases.schema.dropIndex('test_users', 'idx_test_users_email');
-    console.log('Dropped index');
-
-    // Drop table
-    await databases.schema.drop('test_users');
-    console.log('Dropped table');
-
-    console.log(`[TIMING] Cleanup: ${(performance.now() - cleanupStart).toFixed(2)}ms`);
-
-    // ==================== SUMMARY ====================
-
-    const totalTime = performance.now() - startTime;
-    console.log(`\n[TIMING SUMMARY]`);
-    console.log(`  Total time: ${totalTime.toFixed(2)}ms`);
-  })
-  .catch((err) => {
-    console.error('Error in PostgreSQL operations:', err);
-  });*/
-//# sourceMappingURL=test.database.postgres.js.map

package/dist/test/test.database.postgres.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.database.postgres.js","sourceRoot":"","sources":["../../src/test/test.database.postgres.ts"],"names":[],"mappings":";;;;;AAAA,0CAA+D;AAC/D,oDAA8B;AAE9B;;;;;;;;;;;;GAYG;AAEH,MAAM,EAAE,SAAS,EAAE,GAAG,eAAO,CAAC;AAE9B,SAAS,CAAC,MAAM,CAAC;IACf,OAAO,EAAE,iBAAiB;IAC1B,IAAI,EAAE,YAAY;IAClB,GAAG,EAAE,aAAa;IAClB,IAAI,EAAE,uBAAY,CAAC,UAAU;IAC7B,IAAI,EAAE,CAAC;YACL,IAAI,EAAE,KAAK;YACX,cAAc,EAAE,kIAAkI;SACnJ,EAAC;YACA,IAAI,EAAE,KAAK;YACX,cAAc,EAAE,kIAAkI;SACnJ,CAAC;CACH,CAAC,CAAC,IAAI,CAAC,GAAE,EAAE;IACV,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;AAC7C,CAAC,CAAC,CAAA;AAEF,eAAe;AACf,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;AACpC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,8CAA8C,CAAC,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmXO"}

package/dist/test/test.email.brevo.d.ts

@@ -1 +0,0 @@
-export {};