@axova/shared 1.0.0

package/src/schemas/admin/admin-schema.ts

@@ -0,0 +1,208 @@
+import { createId } from "@paralleldrive/cuid2";
+import {
+	boolean,
+	index,
+	integer,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+	varchar,
+} from "drizzle-orm/pg-core";
+
+// Admin Users Table
+export const adminUsers = pgTable(
+	"admin_users",
+	{
+		id: text("id")
+			.primaryKey()
+			.$defaultFn(() => createId()),
+
+		userId: text("user_id").notNull().unique(),
+		email: varchar("email", { length: 255 }).notNull(),
+		name: varchar("name", { length: 255 }).notNull(),
+
+		// Role and Permissions
+		role: varchar("role", { length: 30 })
+			.notNull()
+			.$type<
+				| "SUPER_ADMIN"
+				| "COMPLIANCE_ADMIN"
+				| "CONTENT_MODERATOR"
+				| "CUSTOMER_SUPPORT"
+				| "ANALYST"
+				| "REVIEWER"
+			>(),
+
+		permissions: jsonb("permissions").$type<string[]>().default([]),
+
+		// Status
+		isActive: boolean("is_active").notNull().default(true),
+		lastLoginAt: timestamp("last_login_at", { withTimezone: true }),
+
+		// Department and Team
+		department: varchar("department", { length: 50 }),
+		team: varchar("team", { length: 50 }),
+
+		createdAt: timestamp("created_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp("updated_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => ({
+		userIdIndex: index("idx_admin_users_user_id").on(table.userId),
+		emailIndex: index("idx_admin_users_email").on(table.email),
+		roleIndex: index("idx_admin_users_role").on(table.role),
+		activeIndex: index("idx_admin_users_active").on(table.isActive),
+	}),
+);
+
+// Admin Actions Table
+export const adminActions = pgTable(
+	"admin_actions",
+	{
+		id: text("id")
+			.primaryKey()
+			.$defaultFn(() => createId()),
+
+		adminUserId: text("admin_user_id").notNull(),
+
+		// Action Details
+		actionType: varchar("action_type", { length: 50 })
+			.notNull()
+			.$type<
+				| "COMPLIANCE_OVERRIDE"
+				| "MANUAL_REVIEW"
+				| "STORE_VERIFICATION"
+				| "CONTENT_APPROVAL"
+				| "VIOLATION_DISMISS"
+				| "APPEAL_REVIEW"
+				| "POLICY_UPDATE"
+				| "SYSTEM_CONFIG"
+			>(),
+
+		targetType: varchar("target_type", { length: 30 }).$type<
+			| "STORE"
+			| "USER"
+			| "VIOLATION"
+			| "APPEAL"
+			| "CONTENT"
+			| "POLICY"
+			| "SYSTEM"
+		>(),
+
+		targetId: text("target_id").notNull(),
+
+		// Action Data
+		actionData: jsonb("action_data")
+			.$type<Record<string, unknown>>()
+			.default({}),
+		reason: text("reason").notNull(),
+		notes: text("notes"),
+
+		// Impact and Risk
+		impactLevel: varchar("impact_level", { length: 20 }).$type<
+			"LOW" | "MEDIUM" | "HIGH" | "CRITICAL"
+		>(),
+
+		requiresApproval: boolean("requires_approval").notNull().default(false),
+		approvedBy: text("approved_by"),
+		approvedAt: timestamp("approved_at", { withTimezone: true }),
+
+		createdAt: timestamp("created_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => ({
+		adminUserIndex: index("idx_admin_actions_user").on(table.adminUserId),
+		actionTypeIndex: index("idx_admin_actions_type").on(table.actionType),
+		targetIndex: index("idx_admin_actions_target").on(
+			table.targetType,
+			table.targetId,
+		),
+		approvalIndex: index("idx_admin_actions_approval").on(
+			table.requiresApproval,
+			table.approvedAt,
+		),
+	}),
+);
+
+// Review Queues Table
+export const reviewQueues = pgTable(
+	"review_queues",
+	{
+		id: text("id")
+			.primaryKey()
+			.$defaultFn(() => createId()),
+
+		queueName: varchar("queue_name", { length: 100 }).notNull(),
+		queueType: varchar("queue_type", { length: 30 })
+			.notNull()
+			.$type<
+				| "COMPLIANCE_REVIEW"
+				| "CONTENT_MODERATION"
+				| "STORE_VERIFICATION"
+				| "APPEAL_REVIEW"
+				| "HIGH_RISK_MONITORING"
+			>(),
+
+		// Item Details
+		itemType: varchar("item_type", { length: 30 }).$type<
+			"STORE" | "VIOLATION" | "APPEAL" | "CONTENT" | "USER"
+		>(),
+
+		itemId: text("item_id").notNull(),
+
+		// Priority and Status
+		priority: varchar("priority", { length: 20 })
+			.notNull()
+			.default("NORMAL")
+			.$type<"LOW" | "NORMAL" | "HIGH" | "URGENT" | "CRITICAL">(),
+
+		status: varchar("status", { length: 20 })
+			.notNull()
+			.default("PENDING")
+			.$type<
+				| "PENDING"
+				| "ASSIGNED"
+				| "IN_PROGRESS"
+				| "COMPLETED"
+				| "ESCALATED"
+				| "CANCELLED"
+			>(),
+
+		// Assignment
+		assignedTo: text("assigned_to"),
+		assignedAt: timestamp("assigned_at", { withTimezone: true }),
+
+		// SLA and Timing
+		slaDeadline: timestamp("sla_deadline", { withTimezone: true }),
+		estimatedEffort: integer("estimated_effort"), // minutes
+
+		// Context
+		context: jsonb("context").$type<Record<string, unknown>>().default({}),
+		reviewNotes: text("review_notes"),
+
+		createdAt: timestamp("created_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp("updated_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => ({
+		queueTypeIndex: index("idx_queues_type").on(table.queueType),
+		statusIndex: index("idx_queues_status").on(table.status),
+		assignmentIndex: index("idx_queues_assignment").on(
+			table.assignedTo,
+			table.status,
+		),
+		priorityIndex: index("idx_queues_priority").on(
+			table.priority,
+			table.createdAt,
+		),
+		slaIndex: index("idx_queues_sla").on(table.slaDeadline, table.status),
+	}),
+);

package/src/schemas/ai-moderation/ai-moderation-schema.ts

@@ -0,0 +1,180 @@
+import { createId } from "@paralleldrive/cuid2";
+import {
+	boolean,
+	decimal,
+	index,
+	integer,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+	varchar,
+} from "drizzle-orm/pg-core";
+
+// Content Scans Table
+export const contentScans = pgTable(
+	"content_scans",
+	{
+		id: text("id")
+			.primaryKey()
+			.$defaultFn(() => createId()),
+
+		// Content Information
+		contentId: text("content_id").notNull(),
+		contentType: varchar("content_type", { length: 50 })
+			.notNull()
+			.$type<
+				| "STORE_DESCRIPTION"
+				| "PRODUCT_TITLE"
+				| "PRODUCT_DESCRIPTION"
+				| "BLOG_POST"
+				| "USER_REVIEW"
+				| "STORE_NAME"
+				| "IMAGE"
+				| "VIDEO"
+			>(),
+
+		storeId: text("store_id"),
+		userId: text("user_id"),
+
+		// Scan Configuration
+		scanType: varchar("scan_type", { length: 30 })
+			.$type<"AUTOMATED" | "MANUAL" | "SCHEDULED" | "TRIGGERED">()
+			.default("AUTOMATED"),
+
+		provider: varchar("provider", { length: 30 })
+			.default("OPENAI")
+			.$type<
+				"OPENAI" | "GOOGLE_PERSPECTIVE" | "AZURE_CONTENT_SAFETY" | "INTERNAL"
+			>(),
+
+		// Content Data
+		originalContent: text("original_content").notNull(),
+		processedContent: text("processed_content"), // Cleaned/normalized content
+		contentHash: varchar("content_hash", { length: 64 }), // SHA-256 for deduplication
+
+		// Scan Results
+		flagged: boolean("flagged").notNull().default(false),
+		confidence: decimal("confidence", { precision: 5, scale: 4 }), // 0-1
+
+		// OpenAI Moderation Categories
+		categories: jsonb("categories").$type<{
+			sexual?: boolean;
+			hate?: boolean;
+			harassment?: boolean;
+			selfHarm?: boolean;
+			sexualMinors?: boolean;
+			hateThreatening?: boolean;
+			violenceGraphic?: boolean;
+			selfHarmIntent?: boolean;
+			selfHarmInstructions?: boolean;
+			harassmentThreatening?: boolean;
+			violence?: boolean;
+		}>(),
+
+		categoryScores: jsonb("category_scores").$type<{
+			sexual?: number;
+			hate?: number;
+			harassment?: number;
+			selfHarm?: number;
+			sexualMinors?: number;
+			hateThreatening?: number;
+			violenceGraphic?: number;
+			selfHarmIntent?: number;
+			selfHarmInstructions?: number;
+			harassmentThreatening?: number;
+			violence?: number;
+		}>(),
+
+		// Custom Rules and Patterns
+		customViolations: jsonb("custom_violations")
+			.$type<
+				Array<{
+					ruleId: string;
+					ruleName: string;
+					matched: boolean;
+					confidence: number;
+					matchedText?: string;
+				}>
+			>()
+			.default([]),
+
+		// Status and Actions
+		status: varchar("status", { length: 20 })
+			.notNull()
+			.default("COMPLETED")
+			.$type<"PENDING" | "PROCESSING" | "COMPLETED" | "FAILED" | "CANCELLED">(),
+
+		actionTaken: varchar("action_taken", { length: 30 }).$type<
+			"NONE" | "FLAGGED" | "BLOCKED" | "QUARANTINED" | "REPORTED"
+		>(),
+
+		// Processing Metadata
+		processingTime: integer("processing_time"), // milliseconds
+		cost: decimal("cost", { precision: 8, scale: 6 }), // API cost in USD
+
+		createdAt: timestamp("created_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => ({
+		contentIdIndex: index("idx_scans_content").on(table.contentId),
+		storeIdIndex: index("idx_scans_store").on(table.storeId),
+		flaggedIndex: index("idx_scans_flagged").on(
+			table.flagged,
+			table.confidence,
+		),
+		statusIndex: index("idx_scans_status").on(table.status),
+		contentTypeIndex: index("idx_scans_content_type").on(table.contentType),
+		hashIndex: index("idx_scans_hash").on(table.contentHash),
+	}),
+);
+
+// Moderation Rules Table
+export const moderationRules = pgTable(
+	"moderation_rules",
+	{
+		id: text("id")
+			.primaryKey()
+			.$defaultFn(() => createId()),
+
+		name: varchar("name", { length: 100 }).notNull(),
+		description: text("description"),
+
+		ruleType: varchar("rule_type", { length: 30 })
+			.notNull()
+			.$type<
+				"KEYWORD_FILTER" | "PATTERN_MATCH" | "ML_CLASSIFIER" | "CUSTOM_LOGIC"
+			>(),
+
+		severity: varchar("severity", { length: 20 })
+			.notNull()
+			.$type<"LOW" | "MEDIUM" | "HIGH" | "CRITICAL">(),
+
+		// Rule Configuration
+		configuration: jsonb("configuration").$type<{
+			keywords?: string[];
+			patterns?: string[];
+			threshold?: number;
+			customLogic?: string;
+		}>(),
+
+		// Targeting
+		contentTypes: jsonb("content_types").$type<string[]>().default([]),
+		storeTypes: jsonb("store_types").$type<string[]>().default([]),
+
+		isActive: boolean("is_active").notNull().default(true),
+
+		createdAt: timestamp("created_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+		updatedAt: timestamp("updated_at", { withTimezone: true })
+			.defaultNow()
+			.notNull(),
+	},
+	(table) => ({
+		nameIndex: index("idx_rules_name").on(table.name),
+		typeIndex: index("idx_rules_type").on(table.ruleType),
+		activeIndex: index("idx_rules_active").on(table.isActive),
+	}),
+);

package/src/schemas/common/common-schemas.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+
+// =====================================================
+// SHARED COMMON SCHEMAS
+// =====================================================
+
+// CUID2 validation schema aligned with createId() from @paralleldrive/cuid2
+export const CuidSchema = z.string().cuid2();
+
+export const GeoLocationSchema = z.object({
+	lat: z.number().min(-90).max(90),
+	lng: z.number().min(-180).max(180),
+	address: z.object({
+		line1: z.string(),
+		line2: z.string().optional(),
+		city: z.string(),
+		state: z.string(),
+		postalCode: z.string(),
+		country: z.string(),
+	}),
+});
+
+export const AuditTrailSchema = z.object({
+	action: z.string(),
+	performedBy: z.string(),
+	performedAt: z.date(),
+	details: z.record(z.any()).optional(),
+	ipAddress: z.string().optional(),
+	userAgent: z.string().optional(),
+});
+
+export const MoneySchema = z.object({
+	amount: z.number(),
+	currency: z.string().length(3).default("USD"),
+});
+
+export const ContactInfoSchema = z.object({
+	name: z.string().optional(),
+	phone: z.string().optional(),
+	email: z.string().email().optional(),
+	alternatePhone: z.string().optional(),
+});
+
+// Allow days that are explicitly closed to omit open/close times
+const DayHoursSchema = z.union([
+	z.object({
+		closed: z.literal(true),
+		open: z.string().optional(),
+		close: z.string().optional(),
+	}),
+	z.object({
+		open: z.string(),
+		close: z.string(),
+		closed: z.literal(false).optional(),
+	}),
+]);
+
+export const BusinessHoursSchema = z.object({
+	timezone: z.string(),
+	monday: DayHoursSchema.optional(),
+	tuesday: DayHoursSchema.optional(),
+	wednesday: DayHoursSchema.optional(),
+	thursday: DayHoursSchema.optional(),
+	friday: DayHoursSchema.optional(),
+	saturday: DayHoursSchema.optional(),
+	sunday: DayHoursSchema.optional(),
+	holidays: z
+		.array(
+			z.object({
+				date: z.string(),
+				name: z.string(),
+				closed: z.boolean().default(true),
+			}),
+		)
+		.optional(),
+});
+
+// Common enum types
+export const CurrencyEnum = z.enum([
+	"USD",
+	"EUR",
+	"GBP",
+	"CAD",
+	"AUD",
+	"JPY",
+	"CNY",
+	"INR",
+]);
+export const TimezoneEnum = z.enum([
+	"UTC",
+	"America/New_York",
+	"America/Chicago",
+	"America/Denver",
+	"America/Los_Angeles",
+	"Europe/London",
+	"Europe/Paris",
+	"Europe/Berlin",
+	"Asia/Tokyo",
+	"Asia/Shanghai",
+	"Asia/Kolkata",
+	"Australia/Sydney",
+]);
+
+export type GeoLocation = z.infer<typeof GeoLocationSchema>;
+export type AuditTrail = z.infer<typeof AuditTrailSchema>;
+export type Money = z.infer<typeof MoneySchema>;
+export type ContactInfo = z.infer<typeof ContactInfoSchema>;
+export type BusinessHours = z.infer<typeof BusinessHoursSchema>;