@umituz/react-native-ai-generation-content 1.12.3 → 1.12.5

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -0,0 +1,64 @@
+/**
+ * Image Content Moderator
+ * Validates and moderates image URIs
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_PROTOCOLS = ["http:", "https:", "file:", "data:"];
+const DEFAULT_MAX_URI_LENGTH = 2048;
+
+class ImageModerator extends BaseModerator {
+  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private maxUriLength = DEFAULT_MAX_URI_LENGTH;
+
+  setAllowedProtocols(protocols: string[]): void {
+    this.allowedProtocols = protocols;
+  }
+
+  setMaxUriLength(length: number): void {
+    this.maxUriLength = length;
+  }
+
+  moderate(imageUri: string): ModerationResult {
+    const validationError = this.validate(imageUri);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    return { isAllowed: true, violations: [] };
+  }
+
+  private validate(uri: string): Violation | null {
+    if (!uri || typeof uri !== "string") {
+      return this.createViolation("empty-uri", "Image Validation", "empty URI");
+    }
+
+    if (uri.length > this.maxUriLength) {
+      return this.createViolation(
+        "uri-too-long",
+        "Image Validation",
+        "URI too long"
+      );
+    }
+
+    if (!this.hasValidProtocol(uri)) {
+      return this.createViolation(
+        "invalid-protocol",
+        "Image Validation",
+        "invalid protocol"
+      );
+    }
+
+    return null;
+  }
+
+  private hasValidProtocol(uri: string): boolean {
+    return this.allowedProtocols.some((protocol) =>
+      uri.toLowerCase().startsWith(protocol)
+    );
+  }
+}
+
+export const imageModerator = new ImageModerator();

package/src/domains/content-moderation/infrastructure/services/moderators/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Moderators Index
+ * Exports all content moderators
+ */
+
+export { textModerator } from "./text.moderator";
+export { imageModerator } from "./image.moderator";
+export { videoModerator } from "./video.moderator";
+export { voiceModerator } from "./voice.moderator";
+export { BaseModerator, type ModerationResult } from "./base.moderator";

package/src/domains/content-moderation/infrastructure/services/moderators/text.moderator.ts

@@ -0,0 +1,144 @@
+/**
+ * Text Content Moderator
+ * Validates and moderates text content
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { patternMatcherService } from "../pattern-matcher.service";
+import { rulesRegistry } from "../../rules/rules-registry";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+declare const __DEV__: boolean;
+
+const DEFAULT_MAX_LENGTH = 10000;
+
+const MALICIOUS_CODE_PATTERNS = [
+  /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+  /javascript:/gi,
+  /on\w+\s*=/gi,
+];
+
+const PROMPT_INJECTION_PATTERNS = [
+  /ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)/gi,
+  /disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?)/gi,
+  /forget\s+(all\s+)?(previous|prior|your)\s+(instructions?|prompts?|rules?)/gi,
+  /you\s+are\s+now\s+(a|an)\s+/gi,
+  /act\s+as\s+(if|though)\s+you/gi,
+  /pretend\s+(you\s+are|to\s+be)/gi,
+  /bypass\s+(your\s+)?(safety|content|moderation)/gi,
+  /override\s+(your\s+)?(restrictions?|limitations?|rules?)/gi,
+  /jailbreak/gi,
+  /DAN\s*mode/gi,
+  /developer\s+mode\s+(enabled|on|activated)/gi,
+  /system\s*:\s*/gi,
+  /\[system\]/gi,
+  /<<\s*sys\s*>>/gi,
+];
+
+class TextModerator extends BaseModerator {
+  private maxLength = DEFAULT_MAX_LENGTH;
+
+  setMaxLength(length: number): void {
+    this.maxLength = length;
+  }
+
+  moderate(content: string): ModerationResult {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextModerator] moderate() called", {
+        contentLength: content?.length ?? 0,
+      });
+    }
+
+    const validationError = this.validate(content);
+    if (validationError) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[TextModerator] validation failed", {
+          ruleId: validationError.ruleId,
+          violationType: validationError.violationType,
+        });
+      }
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    const violations = this.evaluateRules(content);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[TextModerator] moderate() completed", {
+        isAllowed: violations.length === 0,
+        violationsCount: violations.length,
+      });
+    }
+
+    return { isAllowed: violations.length === 0, violations };
+  }
+
+  private validate(content: string): Violation | null {
+    if (!content || typeof content !== "string") {
+      return this.createViolation("empty-content", "Validation", "empty");
+    }
+
+    if (content.length > this.maxLength) {
+      return this.createViolation("too-long", "Validation", "length exceeded");
+    }
+
+    if (this.containsMaliciousCode(content)) {
+      return this.createViolation(
+        "malicious",
+        "Security",
+        "malicious code",
+        "dangerous_content"
+      );
+    }
+
+    if (this.containsPromptInjection(content)) {
+      return this.createViolation(
+        "prompt-injection",
+        "Security",
+        "prompt injection",
+        "dangerous_content"
+      );
+    }
+
+    return null;
+  }
+
+  private containsMaliciousCode(content: string): boolean {
+    return MALICIOUS_CODE_PATTERNS.some((pattern) => pattern.test(content));
+  }
+
+  private containsPromptInjection(content: string): boolean {
+    return PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(content));
+  }
+
+  private evaluateRules(content: string): Violation[] {
+    const rules = rulesRegistry.getRulesByContentType("text");
+    const violations: Violation[] = [];
+
+    for (const rule of rules) {
+      const matches = patternMatcherService.matchAnyPattern(
+        content,
+        rule.patterns
+      );
+      const matched = matches.find((m) => m.matched);
+
+      if (matched) {
+        violations.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          violationType: rule.violationType,
+          severity: rule.severity,
+          matchedPattern: matched.matchedText || "",
+          context: content.slice(0, 100),
+          suggestion: this.getSuggestion(rule.violationType),
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+export const textModerator = new TextModerator();

package/src/domains/content-moderation/infrastructure/services/moderators/video.moderator.ts

@@ -0,0 +1,64 @@
+/**
+ * Video Content Moderator
+ * Validates and moderates video URIs
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_PROTOCOLS = ["http:", "https:", "file:"];
+const DEFAULT_MAX_URI_LENGTH = 2048;
+
+class VideoModerator extends BaseModerator {
+  private allowedProtocols = DEFAULT_PROTOCOLS;
+  private maxUriLength = DEFAULT_MAX_URI_LENGTH;
+
+  setAllowedProtocols(protocols: string[]): void {
+    this.allowedProtocols = protocols;
+  }
+
+  setMaxUriLength(length: number): void {
+    this.maxUriLength = length;
+  }
+
+  moderate(videoUri: string): ModerationResult {
+    const validationError = this.validate(videoUri);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    return { isAllowed: true, violations: [] };
+  }
+
+  private validate(uri: string): Violation | null {
+    if (!uri || typeof uri !== "string") {
+      return this.createViolation("empty-uri", "Video Validation", "empty URI");
+    }
+
+    if (uri.length > this.maxUriLength) {
+      return this.createViolation(
+        "uri-too-long",
+        "Video Validation",
+        "URI too long"
+      );
+    }
+
+    if (!this.hasValidProtocol(uri)) {
+      return this.createViolation(
+        "invalid-protocol",
+        "Video Validation",
+        "invalid protocol"
+      );
+    }
+
+    return null;
+  }
+
+  private hasValidProtocol(uri: string): boolean {
+    return this.allowedProtocols.some((protocol) =>
+      uri.toLowerCase().startsWith(protocol)
+    );
+  }
+}
+
+export const videoModerator = new VideoModerator();

package/src/domains/content-moderation/infrastructure/services/moderators/voice.moderator.ts

@@ -0,0 +1,74 @@
+/**
+ * Voice Content Moderator
+ * Validates and moderates voice/TTS text content
+ */
+
+import type { Violation } from "../../../domain/entities/moderation.types";
+import { patternMatcherService } from "../pattern-matcher.service";
+import { rulesRegistry } from "../../rules/rules-registry";
+import { BaseModerator, type ModerationResult } from "./base.moderator";
+
+const DEFAULT_MAX_LENGTH = 5000;
+
+class VoiceModerator extends BaseModerator {
+  private maxLength = DEFAULT_MAX_LENGTH;
+
+  setMaxLength(length: number): void {
+    this.maxLength = length;
+  }
+
+  moderate(text: string): ModerationResult {
+    const validationError = this.validate(text);
+    if (validationError) {
+      return { isAllowed: false, violations: [validationError] };
+    }
+
+    const violations = this.evaluateRules(text);
+    return { isAllowed: violations.length === 0, violations };
+  }
+
+  private validate(text: string): Violation | null {
+    if (!text || typeof text !== "string") {
+      return this.createViolation("empty-text", "Voice Validation", "empty");
+    }
+
+    if (text.length > this.maxLength) {
+      return this.createViolation(
+        "too-long",
+        "Voice Validation",
+        "length exceeded"
+      );
+    }
+
+    return null;
+  }
+
+  private evaluateRules(text: string): Violation[] {
+    const rules = rulesRegistry.getRulesByContentType("voice");
+    const violations: Violation[] = [];
+
+    for (const rule of rules) {
+      const matches = patternMatcherService.matchAnyPattern(
+        text,
+        rule.patterns
+      );
+      const matched = matches.find((m) => m.matched);
+
+      if (matched) {
+        violations.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          violationType: rule.violationType,
+          severity: rule.severity,
+          matchedPattern: matched.matchedText || "",
+          context: text.slice(0, 100),
+          suggestion: this.getSuggestion(rule.violationType),
+        });
+      }
+    }
+
+    return violations;
+  }
+}
+
+export const voiceModerator = new VoiceModerator();

package/src/domains/content-moderation/infrastructure/services/pattern-matcher.service.ts

@@ -0,0 +1,51 @@
+/**
+ * Pattern Matcher Service
+ * Utility service for regex pattern matching
+ */
+
+export interface PatternMatch {
+  pattern: string;
+  matched: boolean;
+  matchedText?: string;
+  position?: number;
+}
+
+class PatternMatcherService {
+  matchPattern(content: string, pattern: string): PatternMatch {
+    try {
+      const regex = new RegExp(pattern, "gi");
+      const match = regex.exec(content);
+
+      if (match) {
+        return {
+          pattern,
+          matched: true,
+          matchedText: match[0],
+          position: match.index,
+        };
+      }
+
+      return { pattern, matched: false };
+    } catch {
+      return { pattern, matched: false };
+    }
+  }
+
+  matchAnyPattern(content: string, patterns: string[]): PatternMatch[] {
+    return patterns.map((pattern) => this.matchPattern(content, pattern));
+  }
+
+  matchAllPatterns(content: string, patterns: string[]): boolean {
+    return patterns.every(
+      (pattern) => this.matchPattern(content, pattern).matched
+    );
+  }
+
+  hasAnyMatch(content: string, patterns: string[]): boolean {
+    return patterns.some(
+      (pattern) => this.matchPattern(content, pattern).matched
+    );
+  }
+}
+
+export const patternMatcherService = new PatternMatcherService();

package/src/domains/content-moderation/presentation/exceptions/content-policy-violation.exception.ts

@@ -0,0 +1,48 @@
+/**
+ * Content Policy Violation Exception
+ * Custom error class for content policy violations
+ */
+
+import type {
+  Violation,
+  ViolationType,
+} from "../../domain/entities/moderation.types";
+
+export class ContentPolicyViolationError extends Error {
+  public readonly violations: Violation[];
+
+  constructor(violations: Violation[], message?: string) {
+    const defaultMessage = `Content policy violation: ${violations
+      .map((v) => v.ruleName)
+      .join(", ")}`;
+    super(message || defaultMessage);
+    this.name = "ContentPolicyViolationError";
+    this.violations = violations;
+  }
+
+  getUserMessage(): string {
+    if (this.violations.length === 0) {
+      return "Content policy violation detected.";
+    }
+
+    const firstViolation = this.violations[0];
+    return firstViolation?.suggestion || "Please modify your content.";
+  }
+
+  getViolationTypes(): ViolationType[] {
+    return this.violations.map((v) => v.violationType);
+  }
+
+  hasViolationType(type: ViolationType): boolean {
+    return this.violations.some((v) => v.violationType === type);
+  }
+
+  getSeverityLevel(): "low" | "medium" | "high" | "critical" {
+    const severities = this.violations.map((v) => v.severity);
+
+    if (severities.includes("critical")) return "critical";
+    if (severities.includes("high")) return "high";
+    if (severities.includes("medium")) return "medium";
+    return "low";
+  }
+}

package/src/domains/creations/application/services/CreationsService.ts

@@ -0,0 +1,71 @@
+import { serverTimestamp, addDoc, collection } from "firebase/firestore";
+import { generateUUID } from "@umituz/react-native-uuid";
+import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
+import type { ICreationsStorageService } from "../../domain/services/ICreationsStorageService";
+import type { CreationType } from "../../domain/value-objects";
+import { BaseRepository } from "@umituz/react-native-firebase";
+
+export interface CreateCreationDTO {
+    userId: string;
+    type: CreationType;
+    prompt: string;
+    metadata?: Record<string, any>;
+    imageUri: string; // can be local file uri or base64
+    aspectRatio?: number;
+}
+
+export class CreationsService extends BaseRepository {
+    constructor(
+        private readonly repository: ICreationsRepository,
+        private readonly storageService: ICreationsStorageService,
+        private readonly collectionName: string = "creations" // Default to generic name, app can override via repo
+    ) {
+        super();
+    }
+
+    async saveCreation(dto: CreateCreationDTO): Promise<string> {
+        const db = this.getDb();
+        if (!db) throw new Error("Firestore not initialized");
+
+        try {
+            const creationId = generateUUID();
+
+            const imageUrl = await this.storageService.uploadCreationImage(
+                dto.userId,
+                creationId,
+                dto.imageUri
+            );
+
+            await this.repository.create(dto.userId, {
+                id: creationId,
+                uri: imageUrl,
+                type: dto.type.id,
+                prompt: dto.prompt,
+                metadata: dto.metadata,
+                createdAt: new Date(),
+                isShared: false,
+            });
+
+            return creationId;
+        } catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+
+    async getCreation(userId: string, id: string): Promise<any> {
+        return this.repository.getById(userId, id);
+    }
+
+    async updateCreation(
+        userId: string,
+        id: string,
+        updates: { metadata?: Record<string, any> },
+    ): Promise<boolean> {
+        return this.repository.update(userId, id, updates);
+    }
+
+    async deleteCreation(userId: string, id: string): Promise<boolean> {
+        return this.repository.delete(userId, id);
+    }
+}

package/src/domains/creations/domain/entities/Creation.ts

@@ -0,0 +1,51 @@
+/**
+ * Creation Entity
+ * Represents an AI-generated creation
+ */
+
+export interface Creation {
+  readonly id: string;
+  readonly uri: string;
+  readonly type: string;
+  readonly prompt?: string;
+  readonly metadata?: Record<string, any>;
+  readonly originalUri?: string;
+  readonly createdAt: Date;
+  readonly isShared: boolean;
+}
+
+export interface CreationDocument {
+  readonly uri?: string;
+  readonly prompt?: string;
+  readonly metadata?: Record<string, any>;
+  readonly originalImage?: string;
+  readonly originalImageUrl?: string;
+  readonly transformedImage?: string;
+  readonly transformedImageUrl?: string;
+  readonly transformationType?: string;
+  readonly type?: string;
+  readonly status?: string;
+  readonly isShared: boolean;
+  readonly createdAt: FirebaseTimestamp | Date; // Allow Date for writing
+  readonly completedAt?: FirebaseTimestamp | Date;
+}
+
+interface FirebaseTimestamp {
+  toDate: () => Date;
+}
+
+export function mapDocumentToCreation(
+  id: string,
+  data: CreationDocument,
+): Creation {
+  return {
+    id,
+    uri: data.transformedImageUrl || data.transformedImage || data.uri || "",
+    type: data.transformationType || data.type || "unknown",
+    prompt: data.prompt,
+    metadata: data.metadata,
+    originalUri: data.originalImageUrl || data.originalImage,
+    createdAt: (data.createdAt as any)?.toDate?.() || (data.createdAt instanceof Date ? data.createdAt : new Date()),
+    isShared: data.isShared ?? false,
+  };
+}

package/src/domains/creations/domain/entities/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Domain Entities
+ */
+
+export type { Creation, CreationDocument } from "./Creation";
+export { mapDocumentToCreation } from "./Creation";

package/src/domains/creations/domain/repositories/ICreationsRepository.ts

@@ -0,0 +1,23 @@
+/**
+ * Creations Repository Interface
+ * Defines the contract for creations data access
+ */
+
+import type { Creation } from "../entities/Creation";
+
+export interface ICreationsRepository {
+  getAll(userId: string): Promise<Creation[]>;
+  getById(userId: string, id: string): Promise<Creation | null>;
+  create(userId: string, creation: Creation): Promise<void>;
+  update(
+    userId: string,
+    id: string,
+    updates: Partial<Creation>,
+  ): Promise<boolean>;
+  delete(userId: string, creationId: string): Promise<boolean>;
+  updateShared(
+    userId: string,
+    creationId: string,
+    isShared: boolean,
+  ): Promise<boolean>;
+}

package/src/domains/creations/domain/repositories/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Domain Repository Interfaces
+ */
+
+export type { ICreationsRepository } from "./ICreationsRepository";

package/src/domains/creations/domain/services/ICreationsStorageService.ts

@@ -0,0 +1,13 @@
+export interface ICreationsStorageService {
+    uploadCreationImage(
+        userId: string,
+        creationId: string,
+        imageUri: string,
+        mimeType?: string
+    ): Promise<string>;
+
+    deleteCreationImage(
+        userId: string,
+        creationId: string
+    ): Promise<boolean>;
+}