@plyaz/core 1.2.0 → 1.3.0

package/dist/web_app/auth/update_user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update_user.d.ts","sourceRoot":"","sources":["../../../src/web_app/auth/update_user.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,GAAU,CAAC,SAAS,MAAM,EAC/C,OAAO,MAAM,EACb,IAAI,MAAM,EACV,OAAO,CAAC,KACP,OAAO,CAAC,OAAO,CAIjB,CAAC"}
+{"version":3,"file":"update_user.d.ts","sourceRoot":"","sources":["../../../src/web_app/auth/update_user.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,GAAU,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,OAAO,MAAM,EACb,IAAI,MAAM,EACV,OAAO,CAAC,KACP,OAAO,CAAC,OAAO,CAIjB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plyaz/core",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Shared core logic and utilities for Plyaz apps, services, and future SDKs – centralized, reusable, and scalable.",
   "type": "module",
   "keywords": [],
@@ -15,11 +15,29 @@
       "require": "./dist/index.js",
       "default": "./dist/index.mjs"
     },
+    "./frontend": {
+      "types": "./dist/entry-frontend.d.ts",
+      "import": "./dist/entry-frontend.mjs",
+      "require": "./dist/entry-frontend.js",
+      "default": "./dist/entry-frontend.mjs"
+    },
+    "./backend": {
+      "types": "./dist/entry-backend.d.ts",
+      "import": "./dist/entry-backend.mjs",
+      "require": "./dist/entry-backend.js",
+      "default": "./dist/entry-backend.mjs"
+    },
+    "./nestjs": {
+      "types": "./dist/init/nestjs/index.d.ts",
+      "import": "./dist/init/nestjs/index.mjs",
+      "require": "./dist/init/nestjs/index.js",
+      "default": "./dist/init/nestjs/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "engines": {
-    "node": ">=22.4.0",
-    "pnpm": ">=8.0.0"
+    "node": ">=23.0.0",
+    "pnpm": ">=8.10.0"
   },
   "author": "Redeemer Pace",
   "license": "ISC",
@@ -29,24 +47,33 @@
   "dependencies": {
     "@nestjs/common": "^11.1.3",
     "@nestjs/core": "^11.1.6",
-    "@plyaz/api": "^1.2.2",
-    "@plyaz/config": "^1.7.18",
-    "@plyaz/db": "^0.1.0",
-    "@plyaz/errors": "^1.3.7",
-    "@plyaz/logger": "^1.3.2",
+    "@nestjs/platform-express": "^11.1.9",
+    "@plyaz/api": "^1.5.5",
+    "@plyaz/config": "^1.9.0",
+    "@plyaz/db": "^0.5.0",
+    "@plyaz/errors": "^1.5.1",
+    "@plyaz/logger": "^1.4.1",
+    "@plyaz/notifications": "^1.0.1",
+    "@plyaz/storage": "^1.0.1",
+    "@plyaz/store": "^1.1.3",
     "@plyaz/translations": "^1.4.5",
-    "@plyaz/types": "^1.15.19",
+    "@plyaz/types": "^1.24.0",
     "@supabase/supabase-js": "^2.79.0",
+    "dd-trace": "^5.80.0",
     "dotenv": "^17.2.3",
     "drizzle-orm": "^0.36.4",
+    "fetchff": "^4.1.0",
+    "hot-shots": "^11.4.0",
     "ioredis": "^5.6.1",
     "next": "15.4.7",
     "postgres": "^3.4.7",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
     "rxjs": "^7.8.2",
     "viem": "^2.31.7",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.0",
+    "zod": "4.1.5",
+    "zustand": "^5.0.9"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.5",
@@ -54,6 +81,8 @@
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.15.0",
     "@eslint/markdown": "^6.5.0",
+    "@nestjs/cli": "^11.0.7",
+    "@nestjs/schematics": "^11.0.5",
     "@next/eslint-plugin-next": "^15.0.3",
     "@plyaz/devtools": "^1.9.4",
     "@plyaz/testing": "^1.5.1",
@@ -62,13 +91,15 @@
     "@testing-library/user-event": "^14.6.1",
     "@types/express": "^5.0.5",
     "@types/node": "^22.14.0",
-    "@types/react": "^19.1.8",
-    "@types/react-dom": "^19.1.6",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
     "@typescript-eslint/eslint-plugin": "^8.15.0",
     "@typescript-eslint/parser": "^8.15.0",
     "@vitest/coverage-istanbul": "3.2.4",
     "@vitest/coverage-v8": "^3.1.3",
     "chalk": "^5.4.1",
+    "commander": "^12.1.0",
+    "cross-env": "^10.1.0",
     "eslint": "^9.29.0",
     "eslint-config-next": "^15.3.3",
     "eslint-config-prettier": "^9.1.0",
@@ -108,6 +139,8 @@
     "standard-version": "^9.5.0",
     "tailwindcss": "^4.1.8",
     "ts-morph": "^26.0.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
     "tsup": "8.5.0",
     "typescript": "^5",
     "typescript-eslint": "^8.34.0",
@@ -135,13 +168,54 @@
     "lint:fix": "eslint ./src ./tests --fix",
     "format": "prettier --write './**/*.{ts,tsx,js,jsx}'",
     "format:check": "prettier --check './**/*.{ts,tsx,js,jsx}'",
-    "type:check": "tsc --noEmit",
+    "type:check": "node --max-old-space-size=8192 node_modules/typescript/bin/tsc --noEmit",
     "test": "vitest run --no-watch",
     "test:ci": "vitest run --no-watch",
     "test:watch": "vitest --watch",
     "test:coverage": "vitest run --coverage",
     "test:ui": "vitest --ui",
     "clean": "rm -rf dist",
+    "example:db": "npx tsx examples/db-service.ts",
+    "nest:dev": "npx tsx --watch server/main.ts",
+    "nest:start": "npx tsx server/main.ts",
+    "nest:start:debug": "npx tsx --inspect server/main.ts",
+    "nest:start:prod": "node dist/server/main.js",
+    "nest:generate": "nest generate",
+    "generate": "npx tsx bin/generate.ts",
+    "generate:feature": "npx tsx bin/generate.ts feature",
+    "generate:list": "npx tsx bin/generate.ts list --files",
+    "generate:info": "npx tsx bin/generate.ts info",
+    "generate:init": "npx tsx bin/generate.ts init",
+    "generate:undo": "npx tsx bin/generate.ts undo",
+    "generate:history": "npx tsx bin/generate.ts history",
+    "generate:no-author": "npx tsx bin/generate.ts feature --no-author",
+    "g": "npx tsx bin/generate.ts",
+    "g:f": "npx tsx bin/generate.ts feature",
+    "g:f:na": "npx tsx bin/generate.ts feature --no-author",
+    "g:u": "npx tsx bin/generate.ts undo",
+    "db:init": "plyaz-db init",
+    "db:version": "plyaz-db version",
+    "db:migrate": "plyaz-db migrate up",
+    "db:migrate:down": "plyaz-db migrate down",
+    "db:migrate:down:all": "plyaz-db migrate reset --confirm",
+    "db:migrate:status": "plyaz-db migrate status",
+    "db:migrate:verify": "plyaz-db migrate verify",
+    "db:migrate:generate-down": "plyaz-db migrate generate-down",
+    "db:migrate:generate-down:write": "plyaz-db migrate generate-down --write",
+    "db:seed": "plyaz-db seed run",
+    "db:seed:status": "plyaz-db seed status",
+    "db:seed:reset": "plyaz-db seed reset --confirm",
+    "db:health": "plyaz-db health",
+    "db:create:migration": "plyaz-db create migration",
+    "db:create:migration:ts": "plyaz-db create migration -t ts",
+    "db:create:migration:i": "plyaz-db create migration -i",
+    "db:create:seed": "plyaz-db create seed",
+    "db:create:seed:sql": "plyaz-db create seed -t sql",
+    "db:create:seed:csv": "plyaz-db create seed -t csv",
+    "db:create:seed:i": "plyaz-db create seed -i",
+    "db:reset": "plyaz-db reset --confirm --drop-schemas --migrate --schemas public,backoffice ",
+    "db:clear": "plyaz-db clear --confirm --schemas public,backoffice,audit",
+    "db:drop": "plyaz-db drop --confirm --all --schemas public,backoffice,audit",
     "audit": "pnpm audit",
     "audit:moderate": "pnpm audit --audit-level moderate",
     "audit:high": "pnpm audit --audit-level high",

package/dist/backend/featureFlags/database/connection.d.ts

@@ -1,321 +0,0 @@
-import { type DatabaseServiceInterface, type Transaction } from '@plyaz/types/db';
-/**
- * DatabaseConnectionManager - Singleton manager for feature flag database connections
- *
- * @description Manages Supabase database connections for the feature flag system using a singleton pattern.
- * Handles connection initialization, table registration, transactions, and cleanup. This is the core
- * database layer that all feature flag operations depend on.
- *
- * **Initialization Flow:**
- * 1. FeatureFlagService calls initialize() during onModuleInit()
- * 2. Reads Supabase credentials from environment variables
- * 3. Creates database service with @plyaz/db
- * 4. Registers feature flag tables
- * 5. Enables caching and other optimizations
- *
- * **Required Environment Variables:**
- * - SUPABASE_URL: Your Supabase project URL
- * - SUPABASE_SERVICE_ROLE_KEY: Service role key for admin operations
- * - SUPABASE_ANON_PUBLIC_KEY: Anonymous key for public operations
- *
- * @example Environment Setup (.env.local)
- * ```bash
- * SUPABASE_URL=https://your-project.supabase.co
- * SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
- * SUPABASE_ANON_PUBLIC_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
- * ```
- *
- * @example Basic Usage (Internal - called by FeatureFlagService)
- * ```typescript
- * // During system initialization:
- * const manager = DatabaseConnectionManager.getInstance();
- * await manager.initialize();
- *
- * // During runtime operations:
- * const db = manager.getDatabase();
- * const flags = await db.query('feature_flags', { limit: 100 });
- * ```
- *
- * @example Transaction Usage
- * ```typescript
- * const manager = DatabaseConnectionManager.getInstance();
- *
- * // Atomic flag creation with rules
- * const result = await manager.transaction(async (tx) => {
- *   // Create flag
- *   const flag = await tx.create('feature_flags', {
- *     key: 'NEW_FEATURE',
- *     value: true,
- *     is_enabled: true
- *   });
- *
- *   // Create associated rule
- *   const rule = await tx.create('feature_flag_rules', {
- *     flag_key: 'NEW_FEATURE',
- *     name: 'Premium Users Only',
- *     conditions: [{ field: 'userRole', operator: 'equals', value: 'premium' }]
- *   });
- *
- *   return { flag, rule };
- * });
- * ```
- *
- */
-export declare class DatabaseConnectionManager {
-    private static instance;
-    private databaseService;
-    private constructor();
-    /**
-     * Gets the singleton instance of DatabaseConnectionManager
-     *
-     * @description Returns the single instance of the connection manager, creating it if it doesn't exist.
-     * This ensures only one database connection pool is maintained across the application.
-     *
-     * @returns {DatabaseConnectionManager} The singleton instance
-     *
-     * @example Getting the Instance
-     * ```typescript
-     * // Always returns the same instance
-     * const manager1 = DatabaseConnectionManager.getInstance();
-     * const manager2 = DatabaseConnectionManager.getInstance();
-     * console.log(manager1 === manager2); // true
-     *
-     * // Use in services
-     * class FeatureFlagRepository {
-     *   private connectionManager = DatabaseConnectionManager.getInstance();
-     *
-     *   async getFlags() {
-     *     const db = this.connectionManager.getDatabase();
-     *     return db.query('feature_flags');
-     *   }
-     * }
-     * ```
-     */
-    static getInstance(): DatabaseConnectionManager;
-    /**
-     * Initializes the database connection and registers feature flag tables
-     *
-     * @description Sets up the Supabase connection using environment variables and registers
-     * all feature flag related tables. This method is idempotent - calling it multiple
-     * times won't create additional connections.
-     *
-     * **What it does:**
-     * 1. Validates required environment variables
-     * 2. Creates Supabase database service
-     * 3. Configures caching (5-minute TTL)
-     * 4. Registers feature flag tables with proper ID columns
-     * 5. Disables audit logging (until tables are created)
-     *
-     * @throws {DatabaseError} When environment variables are missing or connection fails
-     *
-     * @example Initialization Process
-     * ```typescript
-     * // Called automatically by FeatureFlagService.onModuleInit()
-     * const manager = DatabaseConnectionManager.getInstance();
-     *
-     * try {
-     *   await manager.initialize();
-     *   console.log('Database connection established');
-     * } catch (error) {
-     *   console.error('Failed to connect to database:', error.message);
-     *   // Error: Missing environment variables for Supabase connection
-     * }
-     * ```
-     *
-     * @example Environment Variable Validation
-     * ```typescript
-     * // If any of these are missing, initialization fails:
-     * // SUPABASE_URL=undefined
-     * // SUPABASE_SERVICE_ROLE_KEY=undefined
-     * // SUPABASE_ANON_PUBLIC_KEY=undefined
-     *
-     * // Throws: DatabaseError with code CONFIG_REQUIRED
-     * ```
-     *
-     * @example Registered Tables
-     * ```typescript
-     * // These tables are automatically registered:
-     * // - feature_flags (ID: key)
-     * // - feature_flag_rules (ID: id)
-     * // - feature_flag_overrides (ID: id)
-     * // - feature_flag_evaluations (ID: id)
-     * ```
-     */
-    initialize(): Promise<void>;
-    /**
-     * Gets the initialized database service instance
-     *
-     * @description Returns the database service for performing queries. The database must be
-     * initialized first using initialize() method, otherwise this will throw an error.
-     *
-     * @returns {DatabaseServiceInterface} The database service instance
-     * @throws {DatabaseError} When database is not initialized
-     *
-     * @example Basic Usage
-     * ```typescript
-     * const manager = DatabaseConnectionManager.getInstance();
-     * await manager.initialize(); // Must initialize first
-     *
-     * const db = manager.getDatabase();
-     *
-     * // Query feature flags
-     * const result = await db.query('feature_flags', {
-     *   filters: [{ field: 'is_enabled', operator: 'eq', value: true }],
-     *   sort: [{ field: 'key', direction: 'asc' }]
-     * });
-     *
-     * if (result.success) {
-     *   console.log('Found flags:', result.value.data);
-     * }
-     * ```
-     *
-     * @example Error Handling
-     * ```typescript
-     * const manager = DatabaseConnectionManager.getInstance();
-     * // Don't call initialize()
-     *
-     * try {
-     *   const db = manager.getDatabase();
-     * } catch (error) {
-     *   console.error(error.message);
-     *   // "Database not initialized. Call initialize() first."
-     * }
-     * ```
-     *
-     * @example CRUD Operations
-     * ```typescript
-     * const db = manager.getDatabase();
-     *
-     * // Create a flag
-     * const createResult = await db.create('feature_flags', {
-     *   key: 'NEW_FEATURE',
-     *   value: true,
-     *   is_enabled: true
-     * });
-     *
-     * // Update a flag
-     * const updateResult = await db.update('feature_flags', 'NEW_FEATURE', {
-     *   value: false
-     * });
-     *
-     * // Delete a flag
-     * const deleteResult = await db.delete('feature_flags', 'NEW_FEATURE');
-     * ```
-     */
-    getDatabase(): DatabaseServiceInterface;
-    /**
-     * Executes a database transaction with automatic rollback on failure
-     *
-     * @description Provides atomic database operations by wrapping multiple queries in a transaction.
-     * If any operation fails, all changes are rolled back automatically. This is essential for
-     * maintaining data consistency when creating flags with rules or performing bulk operations.
-     *
-     * @template T The return type of the transaction callback
-     * @param {Function} callback - Function that receives transaction object and performs operations
-     * @returns {Promise<T>} The result of the transaction callback
-     * @throws {DatabaseError} When transaction fails or returns no value
-     *
-     * @example Atomic Flag Creation with Rules
-     * ```typescript
-     * const manager = DatabaseConnectionManager.getInstance();
-     *
-     * const result = await manager.transaction(async (tx) => {
-     *   // Create the flag
-     *   const flag = await tx.create('feature_flags', {
-     *     key: 'PREMIUM_CHECKOUT',
-     *     value: true,
-     *     is_enabled: true,
-     *     description: 'Premium checkout flow'
-     *   });
-     *
-     *   // Create targeting rule
-     *   const rule = await tx.create('feature_flag_rules', {
-     *     flag_key: 'PREMIUM_CHECKOUT',
-     *     name: 'Premium Users Only',
-     *     conditions: [
-     *       { field: 'userRole', operator: 'equals', value: 'premium' },
-     *       { field: 'subscriptionActive', operator: 'equals', value: true }
-     *     ],
-     *     value: true,
-     *     priority: 100
-     *   });
-     *
-     *   return { flag, rule };
-     * });
-     *
-     * console.log('Created flag and rule:', result);
-     * ```
-     *
-     * @example Bulk Flag Updates
-     * ```typescript
-     * const flagsToUpdate = ['FEATURE_A', 'FEATURE_B', 'FEATURE_C'];
-     *
-     * await manager.transaction(async (tx) => {
-     *   for (const flagKey of flagsToUpdate) {
-     *     await tx.update('feature_flags', flagKey, {
-     *       is_enabled: false,
-     *       updated_at: new Date().toISOString()
-     *     });
-     *   }
-     *
-     *   // Log the bulk update
-     *   await tx.create('feature_flag_evaluations', {
-     *     flag_key: 'BULK_UPDATE',
-     *     result: { updatedFlags: flagsToUpdate },
-     *     reason: 'bulk_disable',
-     *     evaluated_at: new Date().toISOString()
-     *   });
-     * });
-     * ```
-     *
-     * @example Error Handling and Rollback
-     * ```typescript
-     * try {
-     *   await manager.transaction(async (tx) => {
-     *     await tx.create('feature_flags', { key: 'TEST_FLAG', value: true });
-     *
-     *     // This will cause the entire transaction to rollback
-     *     throw new Error('Something went wrong');
-     *
-     *     // This won't execute, and the flag creation above will be rolled back
-     *     await tx.create('feature_flag_rules', { flag_key: 'TEST_FLAG' });
-     *   });
-     * } catch (error) {
-     *   console.log('Transaction failed, all changes rolled back');
-     * }
-     * ```
-     */
-    transaction<T>(callback: (tx: Transaction) => Promise<T>): Promise<T>;
-    /**
-     * Closes the database connection and cleans up resources
-     *
-     * @description Properly closes the database connection and resets the singleton instance.
-     * This is typically called during application shutdown or in tests that need to reset
-     * the connection state.
-     *
-     * @example Application Shutdown
-     * ```typescript
-     * // In your NestJS module's onModuleDestroy
-     * export class FeatureFlagModule implements OnModuleDestroy {
-     *   async onModuleDestroy() {
-     *     const manager = DatabaseConnectionManager.getInstance();
-     *     await manager.close();
-     *     console.log('Database connection closed');
-     *   }
-     * }
-     * ```
-     *
-     * @example Test Cleanup
-     * ```typescript
-     * describe('Feature Flag Tests', () => {
-     *   afterEach(async () => {
-     *     // Clean up connection between tests
-     *     const manager = DatabaseConnectionManager.getInstance();
-     *     await manager.close();
-     *   });
-     * });
-     * ```
-     */
-    close(): Promise<void>;
-}
-//# sourceMappingURL=connection.d.ts.map

package/dist/backend/featureFlags/database/connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../src/backend/featureFlags/database/connection.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,wBAAwB,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA4B;IACnD,OAAO,CAAC,eAAe,CAAyC;IAEhE,OAAO;IAEP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CAAC,WAAW,IAAI,yBAAyB;IAO/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA4DjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACH,WAAW,IAAI,wBAAwB;IAUvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiFG;IACG,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAe3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B"}