@ductape/sdk 0.0.4-v59 → 0.0.4-v60

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

@@ -0,0 +1,412 @@
+"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

@@ -0,0 +1 @@
+{"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

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