clhq-postgres-module 1.1.0-alpha.172 → 1.1.0-alpha.174

package/dist/migrations/1713000000022-OptimizeMetadataIndexes.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptimizeMetadataIndexes1713000000022 = void 0;
+class OptimizeMetadataIndexes1713000000022 {
+    constructor() {
+        this.name = 'OptimizeMetadataIndexes1713000000022';
+    }
+    async up(queryRunner) {
+        await queryRunner.query(`
+      ALTER TABLE asset_metadata
+      ADD COLUMN IF NOT EXISTS content_embedding_vec vector(1536);
+    `);
+        await queryRunner.query(`
+      UPDATE asset_metadata
+      SET content_embedding_vec = (
+          SELECT array_agg(elem::float)::vector(1536)
+          FROM jsonb_array_elements_text(content_embedding) AS elem
+      )
+      WHERE content_embedding IS NOT NULL
+        AND jsonb_typeof(content_embedding) = 'array'
+        AND content_embedding_vec IS NULL;
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_embedding_hnsw
+      ON asset_metadata
+      USING hnsw (content_embedding_vec vector_cosine_ops)
+      WITH (m = 16, ef_construction = 64);
+    `);
+        await queryRunner.query(`
+      ALTER TABLE project_metadata
+      ADD COLUMN IF NOT EXISTS project_embedding_vec vector(1536);
+    `);
+        await queryRunner.query(`
+      UPDATE project_metadata
+      SET project_embedding_vec = (
+          SELECT array_agg(elem::float)::vector(1536)
+          FROM jsonb_array_elements_text(project_embedding) AS elem
+      )
+      WHERE project_embedding IS NOT NULL
+        AND jsonb_typeof(project_embedding) = 'array'
+        AND project_embedding_vec IS NULL;
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_project_metadata_embedding_hnsw
+      ON project_metadata
+      USING hnsw (project_embedding_vec vector_cosine_ops)
+      WITH (m = 16, ef_construction = 64);
+    `);
+        await queryRunner.query(`
+      ALTER TABLE ai_embeddings
+      ADD COLUMN IF NOT EXISTS embedding_vec vector(1536);
+    `);
+        await queryRunner.query(`
+      UPDATE ai_embeddings
+      SET embedding_vec = (
+          SELECT array_agg(elem::float)::vector(1536)
+          FROM jsonb_array_elements_text(embedding) AS elem
+      )
+      WHERE embedding IS NOT NULL
+        AND jsonb_typeof(embedding) = 'array'
+        AND embedding_vec IS NULL;
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_ai_embeddings_vec_hnsw
+      ON ai_embeddings
+      USING hnsw (embedding_vec vector_cosine_ops)
+      WITH (m = 16, ef_construction = 64);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_user_status
+      ON asset_metadata(user_id, status);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_user_category
+      ON asset_metadata(user_id, category);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_workspace_status
+      ON asset_metadata(workspace_id, status);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_user_last_used
+      ON asset_metadata(user_id, last_used_at DESC NULLS LAST);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_user_usage
+      ON asset_metadata(user_id, usage_count DESC);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_project_metadata_user_updated
+      ON project_metadata(user_id, updated_at DESC);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_project_metadata_workspace_mood
+      ON project_metadata(workspace_id, mood);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_ai_embeddings_user_entity_type
+      ON ai_embeddings(user_id, entity_type);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_activity_user_action_created
+      ON metadata_activity_log(user_id, action, created_at DESC);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_activity_entity_created
+      ON metadata_activity_log(entity_type, entity_id, created_at DESC);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_completed
+      ON asset_metadata(user_id, updated_at DESC)
+      WHERE status = 'completed';
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_asset_metadata_with_embeddings
+      ON asset_metadata(user_id)
+      WHERE content_embedding_vec IS NOT NULL;
+    `);
+        await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION search_similar_assets_optimized(
+          query_embedding vector(1536),
+          p_user_id UUID,
+          p_limit INTEGER DEFAULT 20,
+          p_min_similarity FLOAT DEFAULT 0.5
+      )
+      RETURNS TABLE (
+          asset_id UUID,
+          similarity FLOAT,
+          category TEXT,
+          tags TEXT[],
+          description TEXT,
+          usage_count INTEGER,
+          last_used_at TIMESTAMP WITH TIME ZONE
+      ) AS $$
+      BEGIN
+          RETURN QUERY
+          SELECT
+              am.asset_id,
+              (1 - (am.content_embedding_vec <=> query_embedding))::FLOAT as similarity,
+              am.category,
+              am.tags,
+              am.description,
+              am.usage_count,
+              am.last_used_at
+          FROM asset_metadata am
+          WHERE am.user_id = p_user_id
+            AND am.content_embedding_vec IS NOT NULL
+            AND (1 - (am.content_embedding_vec <=> query_embedding)) >= p_min_similarity
+          ORDER BY am.content_embedding_vec <=> query_embedding
+          LIMIT p_limit;
+      END;
+      $$ LANGUAGE plpgsql;
+    `);
+        await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION search_similar_projects_optimized(
+          query_embedding vector(1536),
+          p_user_id UUID,
+          p_limit INTEGER DEFAULT 10,
+          p_min_similarity FLOAT DEFAULT 0.5
+      )
+      RETURNS TABLE (
+          project_id VARCHAR(255),
+          similarity FLOAT,
+          project_type VARCHAR(100),
+          mood VARCHAR(100),
+          style VARCHAR(100),
+          genre VARCHAR(100)
+      ) AS $$
+      BEGIN
+          RETURN QUERY
+          SELECT
+              pm.project_id,
+              (1 - (pm.project_embedding_vec <=> query_embedding))::FLOAT as similarity,
+              pm.project_type,
+              pm.mood,
+              pm.style,
+              pm.genre
+          FROM project_metadata pm
+          WHERE pm.user_id = p_user_id
+            AND pm.project_embedding_vec IS NOT NULL
+            AND (1 - (pm.project_embedding_vec <=> query_embedding)) >= p_min_similarity
+          ORDER BY pm.project_embedding_vec <=> query_embedding
+          LIMIT p_limit;
+      END;
+      $$ LANGUAGE plpgsql;
+    `);
+        await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION search_embeddings_by_type(
+          query_embedding vector(1536),
+          p_entity_type embedding_entity_type,
+          p_user_id UUID DEFAULT NULL,
+          p_limit INTEGER DEFAULT 20,
+          p_min_similarity FLOAT DEFAULT 0.5
+      )
+      RETURNS TABLE (
+          entity_id VARCHAR(255),
+          similarity FLOAT,
+          source_text TEXT,
+          metadata JSONB
+      ) AS $$
+      BEGIN
+          RETURN QUERY
+          SELECT
+              ae.entity_id,
+              (1 - (ae.embedding_vec <=> query_embedding))::FLOAT as similarity,
+              ae.source_text,
+              ae.metadata
+          FROM ai_embeddings ae
+          WHERE ae.entity_type = p_entity_type
+            AND ae.embedding_vec IS NOT NULL
+            AND (p_user_id IS NULL OR ae.user_id = p_user_id)
+            AND (1 - (ae.embedding_vec <=> query_embedding)) >= p_min_similarity
+          ORDER BY ae.embedding_vec <=> query_embedding
+          LIMIT p_limit;
+      END;
+      $$ LANGUAGE plpgsql;
+    `);
+        await queryRunner.query(`
+      CREATE OR REPLACE FUNCTION sync_embedding_vector()
+      RETURNS TRIGGER AS $$
+      DECLARE
+          vec_result vector(1536);
+      BEGIN
+          IF TG_TABLE_NAME = 'asset_metadata' THEN
+              IF NEW.content_embedding IS NOT NULL AND jsonb_typeof(NEW.content_embedding) = 'array' THEN
+                  SELECT array_agg(elem::float)::vector(1536) INTO vec_result
+                  FROM jsonb_array_elements_text(NEW.content_embedding) AS elem;
+                  NEW.content_embedding_vec := vec_result;
+              ELSE
+                  NEW.content_embedding_vec := NULL;
+              END IF;
+          ELSIF TG_TABLE_NAME = 'project_metadata' THEN
+              IF NEW.project_embedding IS NOT NULL AND jsonb_typeof(NEW.project_embedding) = 'array' THEN
+                  SELECT array_agg(elem::float)::vector(1536) INTO vec_result
+                  FROM jsonb_array_elements_text(NEW.project_embedding) AS elem;
+                  NEW.project_embedding_vec := vec_result;
+              ELSE
+                  NEW.project_embedding_vec := NULL;
+              END IF;
+          ELSIF TG_TABLE_NAME = 'ai_embeddings' THEN
+              IF NEW.embedding IS NOT NULL AND jsonb_typeof(NEW.embedding) = 'array' THEN
+                  SELECT array_agg(elem::float)::vector(1536) INTO vec_result
+                  FROM jsonb_array_elements_text(NEW.embedding) AS elem;
+                  NEW.embedding_vec := vec_result;
+              ELSE
+                  NEW.embedding_vec := NULL;
+              END IF;
+          END IF;
+          RETURN NEW;
+      END;
+      $$ LANGUAGE plpgsql;
+    `);
+        await queryRunner.query(`
+      DROP TRIGGER IF EXISTS sync_asset_metadata_embedding ON asset_metadata;
+      CREATE TRIGGER sync_asset_metadata_embedding
+          BEFORE INSERT OR UPDATE OF content_embedding ON asset_metadata
+          FOR EACH ROW
+          EXECUTE FUNCTION sync_embedding_vector();
+    `);
+        await queryRunner.query(`
+      DROP TRIGGER IF EXISTS sync_project_metadata_embedding ON project_metadata;
+      CREATE TRIGGER sync_project_metadata_embedding
+          BEFORE INSERT OR UPDATE OF project_embedding ON project_metadata
+          FOR EACH ROW
+          EXECUTE FUNCTION sync_embedding_vector();
+    `);
+        await queryRunner.query(`
+      DROP TRIGGER IF EXISTS sync_ai_embeddings_embedding ON ai_embeddings;
+      CREATE TRIGGER sync_ai_embeddings_embedding
+          BEFORE INSERT OR UPDATE OF embedding ON ai_embeddings
+          FOR EACH ROW
+          EXECUTE FUNCTION sync_embedding_vector();
+    `);
+        await queryRunner.query(`
+      CREATE OR REPLACE VIEW v_embedding_stats AS
+      SELECT
+          'asset_metadata' as table_name,
+          COUNT(*) as total_records,
+          COUNT(content_embedding_vec) as records_with_embeddings,
+          ROUND(100.0 * COUNT(content_embedding_vec) / NULLIF(COUNT(*), 0), 2) as embedding_coverage_pct
+      FROM asset_metadata
+      UNION ALL
+      SELECT
+          'project_metadata' as table_name,
+          COUNT(*) as total_records,
+          COUNT(project_embedding_vec) as records_with_embeddings,
+          ROUND(100.0 * COUNT(project_embedding_vec) / NULLIF(COUNT(*), 0), 2) as embedding_coverage_pct
+      FROM project_metadata
+      UNION ALL
+      SELECT
+          'ai_embeddings' as table_name,
+          COUNT(*) as total_records,
+          COUNT(embedding_vec) as records_with_embeddings,
+          ROUND(100.0 * COUNT(embedding_vec) / NULLIF(COUNT(*), 0), 2) as embedding_coverage_pct
+      FROM ai_embeddings;
+    `);
+        await queryRunner.query(`COMMENT ON COLUMN asset_metadata.content_embedding_vec IS 'Native vector column for HNSW-indexed similarity search'`);
+        await queryRunner.query(`COMMENT ON COLUMN project_metadata.project_embedding_vec IS 'Native vector column for HNSW-indexed similarity search'`);
+        await queryRunner.query(`COMMENT ON COLUMN ai_embeddings.embedding_vec IS 'Native vector column for HNSW-indexed similarity search'`);
+        await queryRunner.query(`COMMENT ON FUNCTION search_similar_assets_optimized IS 'Optimized asset search using HNSW index with minimum similarity threshold'`);
+        await queryRunner.query(`COMMENT ON FUNCTION search_similar_projects_optimized IS 'Optimized project search using HNSW index with minimum similarity threshold'`);
+        await queryRunner.query(`COMMENT ON FUNCTION search_embeddings_by_type IS 'Generic embedding search by entity type with optional user filter'`);
+        await queryRunner.query(`COMMENT ON VIEW v_embedding_stats IS 'Monitoring view for embedding coverage across tables'`);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`DROP TRIGGER IF EXISTS sync_asset_metadata_embedding ON asset_metadata`);
+        await queryRunner.query(`DROP TRIGGER IF EXISTS sync_project_metadata_embedding ON project_metadata`);
+        await queryRunner.query(`DROP TRIGGER IF EXISTS sync_ai_embeddings_embedding ON ai_embeddings`);
+        await queryRunner.query(`DROP FUNCTION IF EXISTS sync_embedding_vector`);
+        await queryRunner.query(`DROP FUNCTION IF EXISTS search_similar_assets_optimized`);
+        await queryRunner.query(`DROP FUNCTION IF EXISTS search_similar_projects_optimized`);
+        await queryRunner.query(`DROP FUNCTION IF EXISTS search_embeddings_by_type`);
+        await queryRunner.query(`DROP VIEW IF EXISTS v_embedding_stats`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_embedding_hnsw`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_metadata_embedding_hnsw`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_ai_embeddings_vec_hnsw`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_user_status`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_user_category`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_workspace_status`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_user_last_used`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_user_usage`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_metadata_user_updated`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_metadata_workspace_mood`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_ai_embeddings_user_entity_type`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_activity_user_action_created`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_activity_entity_created`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_completed`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_asset_metadata_with_embeddings`);
+        await queryRunner.query(`ALTER TABLE asset_metadata DROP COLUMN IF EXISTS content_embedding_vec`);
+        await queryRunner.query(`ALTER TABLE project_metadata DROP COLUMN IF EXISTS project_embedding_vec`);
+        await queryRunner.query(`ALTER TABLE ai_embeddings DROP COLUMN IF EXISTS embedding_vec`);
+    }
+}
+exports.OptimizeMetadataIndexes1713000000022 = OptimizeMetadataIndexes1713000000022;

package/dist/migrations/1713000000023-CreateSceneGeneratorTables.d.ts

@@ -0,0 +1,6 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class CreateSceneGeneratorTables1713000000023 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/migrations/1713000000023-CreateSceneGeneratorTables.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSceneGeneratorTables1713000000023 = void 0;
+class CreateSceneGeneratorTables1713000000023 {
+    constructor() {
+        this.name = 'CreateSceneGeneratorTables1713000000023';
+    }
+    async up(queryRunner) {
+        await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE project_scene_job_status AS ENUM ('NEW', 'PROCESSING', 'SUCCESS', 'ERROR');
+      EXCEPTION
+        WHEN duplicate_object THEN null;
+      END $$;
+    `);
+        await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE project_scene_status AS ENUM ('PENDING', 'GENERATING', 'READY', 'FAILED');
+      EXCEPTION
+        WHEN duplicate_object THEN null;
+      END $$;
+    `);
+        await queryRunner.query(`
+      CREATE TABLE project_scene_jobs (
+        id VARCHAR(255) PRIMARY KEY,
+        project_id VARCHAR(255) NOT NULL,
+        user_id UUID NOT NULL REFERENCES users(id),
+        workspace_id UUID,
+        status project_scene_job_status DEFAULT 'NEW',
+        total_scenes INTEGER DEFAULT 0,
+        completed_scenes INTEGER DEFAULT 0,
+        failed_scenes INTEGER DEFAULT 0,
+        interval_seconds INTEGER DEFAULT 5,
+        duration_ms INTEGER,
+        data JSONB,
+        error_message TEXT,
+        started_at TIMESTAMP,
+        completed_at TIMESTAMP,
+        created_at TIMESTAMP DEFAULT NOW(),
+        updated_at TIMESTAMP DEFAULT NOW()
+      );
+    `);
+        await queryRunner.query(`
+      CREATE TABLE project_scenes (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        project_id VARCHAR(255) NOT NULL,
+        job_id VARCHAR(255) REFERENCES project_scene_jobs(id),
+        timestamp FLOAT NOT NULL,
+        status project_scene_status DEFAULT 'PENDING',
+        s3_url TEXT,
+        s3_key TEXT,
+        file_size INTEGER,
+        width INTEGER,
+        height INTEGER,
+        generation_time_ms INTEGER,
+        error_message TEXT,
+        metadata JSONB,
+        created_at TIMESTAMP DEFAULT NOW(),
+        updated_at TIMESTAMP DEFAULT NOW(),
+        UNIQUE(project_id, timestamp)
+      );
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_project_scene_jobs_project_id ON project_scene_jobs(project_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_project_scene_jobs_user_id ON project_scene_jobs(user_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_project_scene_jobs_status ON project_scene_jobs(status);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_project_scenes_project_id ON project_scenes(project_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_project_scenes_project_timestamp ON project_scenes(project_id, timestamp);
+    `);
+        await queryRunner.query(`COMMENT ON TABLE project_scene_jobs IS 'Tracks scene generation jobs for video editor projects'`);
+        await queryRunner.query(`COMMENT ON TABLE project_scenes IS 'Stores individual scene metadata and S3 references'`);
+        await queryRunner.query(`COMMENT ON COLUMN project_scene_jobs.id IS 'Job ID with format scene_job_{uuid}'`);
+        await queryRunner.query(`COMMENT ON COLUMN project_scene_jobs.data IS 'JSONB storage for job results, scene URLs, and error details'`);
+        await queryRunner.query(`COMMENT ON COLUMN project_scenes.timestamp IS 'Scene timestamp in seconds (0, 5, 10, ...)'`);
+        await queryRunner.query(`COMMENT ON COLUMN project_scenes.metadata IS 'JSONB storage for scene generation metadata'`);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_scenes_project_timestamp`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_scenes_project_id`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_scene_jobs_status`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_scene_jobs_user_id`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_project_scene_jobs_project_id`);
+        await queryRunner.query(`DROP TABLE IF EXISTS project_scenes`);
+        await queryRunner.query(`DROP TABLE IF EXISTS project_scene_jobs`);
+        await queryRunner.query(`DROP TYPE IF EXISTS project_scene_status`);
+        await queryRunner.query(`DROP TYPE IF EXISTS project_scene_job_status`);
+    }
+}
+exports.CreateSceneGeneratorTables1713000000023 = CreateSceneGeneratorTables1713000000023;

package/dist/migrations/1713000000024-CreateRemotionRendersTable.d.ts

@@ -0,0 +1,6 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class CreateRemotionRendersTable1713000000024 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/migrations/1713000000024-CreateRemotionRendersTable.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRemotionRendersTable1713000000024 = void 0;
+class CreateRemotionRendersTable1713000000024 {
+    constructor() {
+        this.name = 'CreateRemotionRendersTable1713000000024';
+    }
+    async up(queryRunner) {
+        await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE render_status AS ENUM ('pending', 'rendering', 'completed', 'failed');
+      EXCEPTION
+        WHEN duplicate_object THEN null;
+      END $$;
+    `);
+        await queryRunner.query(`
+      CREATE TABLE remotion_renders (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        project_id VARCHAR(255) NOT NULL,
+        user_id UUID NOT NULL REFERENCES users(id),
+        workspace_id UUID,
+        render_id VARCHAR(255),
+        status render_status DEFAULT 'pending',
+        bucket_name VARCHAR(255) NOT NULL,
+        function_name VARCHAR(255) NOT NULL,
+        region VARCHAR(50) DEFAULT 'ap-southeast-2',
+        output_file_url TEXT,
+        error_message TEXT,
+        retry_count INTEGER DEFAULT 0,
+        composition_id VARCHAR(255),
+        input_props JSONB,
+        render_metadata JSONB,
+        credits_reserved DECIMAL(10, 2),
+        credits_consumed DECIMAL(10, 2),
+        reservation_id UUID,
+        render_cost_metadata JSONB,
+        created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+        updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      );
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_remotion_renders_project_id ON remotion_renders(project_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_remotion_renders_user_id ON remotion_renders(user_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_remotion_renders_render_id ON remotion_renders(render_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_remotion_renders_status ON remotion_renders(status);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX idx_remotion_renders_reservation_id ON remotion_renders(reservation_id);
+    `);
+        await queryRunner.query(`COMMENT ON TABLE remotion_renders IS 'Tracks Remotion video rendering jobs'`);
+        await queryRunner.query(`COMMENT ON COLUMN remotion_renders.render_id IS 'Remotion Lambda render ID'`);
+        await queryRunner.query(`COMMENT ON COLUMN remotion_renders.input_props IS 'JSONB storage for Remotion composition input props'`);
+        await queryRunner.query(`COMMENT ON COLUMN remotion_renders.render_metadata IS 'JSONB storage for render metadata (dimensions, fps, etc.)'`);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_remotion_renders_reservation_id`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_remotion_renders_status`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_remotion_renders_render_id`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_remotion_renders_user_id`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_remotion_renders_project_id`);
+        await queryRunner.query(`DROP TABLE IF EXISTS remotion_renders`);
+        await queryRunner.query(`DROP TYPE IF EXISTS render_status`);
+    }
+}
+exports.CreateRemotionRendersTable1713000000024 = CreateRemotionRendersTable1713000000024;

package/dist/migrations/1713000000025-ExtendCreditAllocationSystem.d.ts

@@ -0,0 +1,6 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+export declare class ExtendCreditAllocationSystem1713000000025 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/migrations/1713000000025-ExtendCreditAllocationSystem.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendCreditAllocationSystem1713000000025 = void 0;
+class ExtendCreditAllocationSystem1713000000025 {
+    constructor() {
+        this.name = 'ExtendCreditAllocationSystem1713000000025';
+    }
+    async up(queryRunner) {
+        await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS plan_credit_configurations (
+        id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+        plan_id VARCHAR(100) UNIQUE NOT NULL,
+        plan_name VARCHAR(100) NOT NULL,
+        cloud_credits_monthly INTEGER DEFAULT 0,
+        cloud_credits_max_rollover INTEGER DEFAULT 0,
+        ai_credits_monthly INTEGER DEFAULT 0,
+        ai_credits_max_rollover INTEGER DEFAULT 0,
+        signup_cloud_bonus INTEGER DEFAULT 0,
+        signup_ai_bonus INTEGER DEFAULT 0,
+        upgrade_bonus_multiplier DECIMAL(5,2) DEFAULT 0.20,
+        is_active BOOLEAN DEFAULT true,
+        features JSONB,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+        await queryRunner.query(`
+      INSERT INTO plan_credit_configurations
+      (plan_id, plan_name, cloud_credits_monthly, cloud_credits_max_rollover, ai_credits_monthly, ai_credits_max_rollover, signup_cloud_bonus, signup_ai_bonus)
+      VALUES
+      ('free', 'Free', 100, 0, 50, 0, 50, 25),
+      ('pro', 'Pro', 500, 500, 250, 250, 100, 50),
+      ('business', 'Business', 2000, 1000, 1000, 500, 500, 250),
+      ('enterprise', 'Enterprise', 10000, 5000, 5000, 2500, 1000, 500)
+      ON CONFLICT (plan_id) DO NOTHING;
+    `);
+        await queryRunner.query(`
+      ALTER TABLE credit_allocations
+      ADD COLUMN IF NOT EXISTS cloud_credits_allocated DECIMAL(10,2) DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS cloud_credits_remaining DECIMAL(10,2) DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS cloud_credits_rollover DECIMAL(10,2) DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS ai_credits_allocated DECIMAL(10,2) DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS ai_credits_remaining DECIMAL(10,2) DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS ai_credits_rollover DECIMAL(10,2) DEFAULT 0,
+      ADD COLUMN IF NOT EXISTS billing_cycle VARCHAR(20) DEFAULT 'monthly',
+      ADD COLUMN IF NOT EXISTS metadata JSONB;
+    `);
+        await queryRunner.query(`
+      UPDATE credit_allocations
+      SET
+        plan_id = 'free',
+        cloud_credits_allocated = credits_allocated,
+        cloud_credits_remaining = credits_remaining,
+        cloud_credits_rollover = rollover_credits,
+        ai_credits_allocated = ai_credits_allocated,
+        ai_credits_remaining = ai_credits_remaining,
+        ai_credits_rollover = 0,
+        billing_cycle = 'monthly'
+      WHERE plan_id IS NULL OR plan_id = '';
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_credit_allocations_user_status ON credit_allocations(user_id, status);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_credit_allocations_period ON credit_allocations(period_start, period_end);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_plan_credit_configurations_plan_id ON plan_credit_configurations(plan_id);
+    `);
+        await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS idx_plan_credit_configurations_active ON plan_credit_configurations(is_active);
+    `);
+        await queryRunner.query(`COMMENT ON TABLE plan_credit_configurations IS 'Credit allocation configurations for each subscription plan'`);
+        await queryRunner.query(`COMMENT ON TABLE credit_allocations IS 'User credit allocations with Cloud and AI credit separation'`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.cloud_credits_allocated IS 'Monthly allocated Cloud/Render credits'`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.ai_credits_allocated IS 'Monthly allocated AI credits'`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.cloud_credits_rollover IS 'Cloud credits rolled over from previous period'`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.ai_credits_rollover IS 'AI credits rolled over from previous period'`);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`COMMENT ON TABLE plan_credit_configurations IS NULL`);
+        await queryRunner.query(`COMMENT ON TABLE credit_allocations IS NULL`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.cloud_credits_allocated IS NULL`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.ai_credits_allocated IS NULL`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.cloud_credits_rollover IS NULL`);
+        await queryRunner.query(`COMMENT ON COLUMN credit_allocations.ai_credits_rollover IS NULL`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_plan_credit_configurations_active`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_plan_credit_configurations_plan_id`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_credit_allocations_period`);
+        await queryRunner.query(`DROP INDEX IF EXISTS idx_credit_allocations_user_status`);
+        await queryRunner.query(`
+      UPDATE credit_allocations
+      SET
+        plan_id = NULL,
+        credits_allocated = cloud_credits_allocated,
+        credits_remaining = cloud_credits_remaining,
+        rollover_credits = cloud_credits_rollover
+      WHERE plan_id = 'free';
+    `);
+        await queryRunner.query(`
+      ALTER TABLE credit_allocations
+      DROP COLUMN IF EXISTS cloud_credits_allocated,
+      DROP COLUMN IF EXISTS cloud_credits_remaining,
+      DROP COLUMN IF EXISTS cloud_credits_rollover,
+      DROP COLUMN IF EXISTS ai_credits_allocated,
+      DROP COLUMN IF EXISTS ai_credits_remaining,
+      DROP COLUMN IF EXISTS ai_credits_rollover,
+      DROP COLUMN IF EXISTS billing_cycle,
+      DROP COLUMN IF EXISTS metadata;
+    `);
+        await queryRunner.query(`DROP TABLE IF EXISTS plan_credit_configurations`);
+    }
+}
+exports.ExtendCreditAllocationSystem1713000000025 = ExtendCreditAllocationSystem1713000000025;

package/dist/migrations/{1713000000002-AddIsActiveToWorkspaceMembers.d.ts → 1713000000026-AddStatusToCreditTransactions.d.ts}

@@ -1,5 +1,5 @@
 import { MigrationInterface, QueryRunner } from 'typeorm';
-export declare class AddIsActiveToWorkspaceMembers1713000000002 implements MigrationInterface {
+export declare class AddStatusToCreditTransactions1713000000026 implements MigrationInterface {
     name: string;
     up(queryRunner: QueryRunner): Promise<void>;
     down(queryRunner: QueryRunner): Promise<void>;