insforge 0.3.2 → 1.2.10

package/package.json

@@ -1,24 +1,27 @@
 {
   "name": "insforge",
-  "version": "0.3.2",
+  "version": "1.2.10",
   "description": "InsForge - Open source backend-as-a-service with PostgreSQL and MCP integration",
   "type": "module",
   "workspaces": [
     "backend",
     "frontend",
+    "auth",
     "shared-schemas",
     "mcp"
   ],
   "scripts": {
-    "dev": "concurrently -n \"backend,frontend\" -c \"cyan,magenta\" \"npm run dev:backend\" \"npm run dev:frontend\"",
-    "dev:debug": "concurrently -n \"backend,frontend\" -c \"cyan,magenta\" \"npm run dev:backend:debug\" \"npm run dev:frontend:debug\"",
+    "dev": "concurrently -n \"backend,frontend,auth\" -c \"cyan,magenta,green\" \"npm run dev:backend\" \"npm run dev:frontend\" \"npm run dev:auth\"",
+    "dev:debug": "concurrently -n \"backend,frontend,auth\" -c \"cyan,magenta,green\" \"npm run dev:backend:debug\" \"npm run dev:frontend:debug\" \"npm run dev:auth\"",
     "dev:backend": "cd backend && npm run dev",
     "dev:backend:debug": "cd backend && cross-env DEBUG_MODE=true npm run dev",
     "dev:frontend": "cd frontend && npm run dev",
     "dev:frontend:debug": "cd frontend && cross-env VITE_DEBUG_MODE=true npm run dev",
-    "build": "npm run build:backend && npm run build:frontend",
+    "dev:auth": "cd auth && npm run dev",
+    "build": "npm run build:backend && npm run build:frontend && npm run build:auth",
     "build:backend": "cd backend && npm run build",
     "build:frontend": "cd frontend && npm run build",
+    "build:auth": "cd auth && npm run build",
     "start": "cd backend && npm run start",
     "start:prod": "npm run build && npm run start",
     "test": "npm run test:backend && npm run test:frontend",
@@ -28,26 +31,32 @@
     "lint": "eslint .",
     "lint:backend": "eslint backend",
     "lint:frontend": "eslint frontend",
+    "lint:auth": "eslint auth",
     "lint:mcp": "eslint mcp",
     "lint:fix": "eslint . --fix",
     "lint:fix:backend": "eslint backend --fix",
     "lint:fix:frontend": "eslint frontend --fix",
+    "lint:fix:auth": "eslint auth --fix",
     "lint:fix:mcp": "eslint mcp --fix",
     "format": "prettier --write .",
     "format:backend": "prettier --write backend",
     "format:frontend": "prettier --write frontend",
+    "format:auth": "prettier --write auth",
     "format:mcp": "prettier --write mcp",
     "format:check": "prettier --check .",
     "format:check:backend": "prettier --check backend",
     "format:check:frontend": "prettier --check frontend",
+    "format:check:auth": "prettier --check auth",
     "format:check:mcp": "prettier --check mcp",
-    "typecheck": "npm run typecheck:frontend && npm run typecheck:backend",
+    "typecheck": "npm run typecheck:frontend && npm run typecheck:backend && npm run typecheck:auth",
     "typecheck:frontend": "cd frontend && npx tsc --noEmit",
     "typecheck:backend": "cd backend && npx tsc --noEmit",
-    "clean": "npm run clean:backend && npm run clean:frontend",
+    "typecheck:auth": "cd auth && npx tsc --noEmit",
+    "clean": "npm run clean:backend && npm run clean:frontend && npm run clean:auth",
     "clean:backend": "cd backend && npm run clean",
     "clean:frontend": "cd frontend && rimraf dist",
-    "install:all": "npm install && cd backend && npm install && cd ../frontend && npm install",
+    "clean:auth": "cd auth && rimraf dist",
+    "install:all": "npm install && cd backend && npm install && cd ../frontend && npm install && cd ../auth && npm install",
     "release": "release-it",
     "release:patch": "release-it patch",
     "release:minor": "release-it minor",

package/shared-schemas/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insforge/shared-schemas",
-  "version": "1.1.1",
+  "version": "1.1.23",
   "author": "Insforge",
   "description": "Shared TypeScript schemas for InsForge frontend and backend",
   "license": "Apache-2.0",

package/shared-schemas/src/ai-api.schema.ts

@@ -1,18 +1,36 @@
 import { z } from 'zod';
-import { aiConfigurationSchema, aiUsageRecordSchema } from './ai.schema';
+import { aiConfigurationSchema, aiUsageRecordSchema, modalitySchema } from './ai.schema';
 
 // ============= Chat Completion Schemas =============
 
+// OpenAI-compatible content schemas
+export const textContentSchema = z.object({
+  type: z.literal('text'),
+  text: z.string(),
+});
+
+export const imageContentSchema = z.object({
+  type: z.literal('image_url'),
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  image_url: z.object({
+    // URL can be either a public URL or base64-encoded data URI
+    // Examples:
+    // - Public URL: "https://example.com/image.jpg"
+    // - Base64: "data:image/jpeg;base64,/9j/4AAQ..."
+    url: z.string(),
+    detail: z.enum(['auto', 'low', 'high']).optional(),
+  }),
+});
+
+export const contentSchema = z.union([textContentSchema, imageContentSchema]);
+
+// Chat message supports both OpenAI format and legacy format for backward compatibility
 export const chatMessageSchema = z.object({
   role: z.enum(['user', 'assistant', 'system']),
-  content: z.string(),
-  images: z
-    .array(
-      z.object({
-        url: z.string(),
-      })
-    )
-    .optional(),
+  // New format: content can be string or array of content parts (OpenAI-compatible)
+  content: z.union([z.string(), z.array(contentSchema)]),
+  // Legacy format: separate images field (deprecated but supported for backward compatibility)
+  images: z.array(z.object({ url: z.string() })).optional(),
 });
 
 export const chatCompletionRequestSchema = z.object({
@@ -76,54 +94,13 @@ export const imageGenerationResponseSchema = z.object({
     .optional(),
 });
 
-// OpenRouter-specific model schema
-export const openRouterModelSchema = z.object({
+export const aiModelSchema = z.object({
   id: z.string(),
-  name: z.string(),
-  created: z.number(),
-  description: z.string().optional(),
-  architecture: z
-    .object({
-      inputModalities: z.array(z.string()),
-      outputModalities: z.array(z.string()),
-      tokenizer: z.string(),
-      instructType: z.string(),
-    })
-    .optional(),
-  topProvider: z
-    .object({
-      isModerated: z.boolean(),
-      contextLength: z.number(),
-      maxCompletionTokens: z.number(),
-    })
-    .optional(),
-  pricing: z.object({
-    prompt: z.string(),
-    completion: z.string(),
-    image: z.string().optional(),
-    request: z.string().optional(),
-    webSearch: z.string().optional(),
-    internalReasoning: z.string().optional(),
-    inputCacheRead: z.string().optional(),
-    inputCacheWrite: z.string().optional(),
-  }),
-});
-
-export const listModelsResponseSchema = z.object({
-  text: z.array(
-    z.object({
-      provider: z.string(),
-      configured: z.boolean(),
-      models: z.array(openRouterModelSchema),
-    })
-  ),
-  image: z.array(
-    z.object({
-      provider: z.string(),
-      configured: z.boolean(),
-      models: z.array(openRouterModelSchema),
-    })
-  ),
+  inputModality: z.array(modalitySchema).min(1),
+  outputModality: z.array(modalitySchema).min(1),
+  provider: z.string(),
+  modelId: z.string(),
+  priceLevel: z.number().min(0).max(3).optional(),
 });
 
 export const createAIConfigurationRequestSchema = aiConfigurationSchema.omit({
@@ -158,8 +135,7 @@ export type ChatCompletionRequest = z.infer<typeof chatCompletionRequestSchema>;
 export type ChatCompletionResponse = z.infer<typeof chatCompletionResponseSchema>;
 export type ImageGenerationRequest = z.infer<typeof imageGenerationRequestSchema>;
 export type ImageGenerationResponse = z.infer<typeof imageGenerationResponseSchema>;
-export type OpenRouterModel = z.infer<typeof openRouterModelSchema>;
-export type ListModelsResponse = z.infer<typeof listModelsResponseSchema>;
+export type AIModelSchema = z.infer<typeof aiModelSchema>;
 export type CreateAIConfigurationRequest = z.infer<typeof createAIConfigurationRequestSchema>;
 export type UpdateAIConfigurationRequest = z.infer<typeof updateAIConfigurationRequestSchema>;
 export type ListAIUsageResponse = z.infer<typeof listAIUsageResponseSchema>;

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

@@ -35,6 +35,11 @@ export const aiUsageDataSchema = z.object({
 export const aiUsageRecordSchema = aiUsageDataSchema.extend({
   id: z.string().uuid(),
   createdAt: z.date(),
+  modelId: z.string().nullable().optional(),
+  model: z.string().nullable(),
+  provider: z.string().nullable(),
+  inputModality: z.array(modalitySchema).nullable(),
+  outputModality: z.array(modalitySchema).nullable(),
 });
 
 export const aiUsageSummarySchema = z.object({

package/shared-schemas/src/auth-api.schema.ts

@@ -7,6 +7,8 @@ import {
   roleSchema,
   userSchema,
   oAuthConfigSchema,
+  oAuthProvidersSchema,
+  authConfigSchema,
 } from './auth.schema';
 
 // ============================================================================
@@ -63,22 +65,107 @@ export const deleteUsersRequestSchema = z.object({
   userIds: z.array(userIdSchema).min(1, 'At least one user ID is required'),
 });
 
+/**
+ * POST /api/auth/email/send-verification - Send verification email (code or link based on config)
+ */
+export const sendVerificationEmailRequestSchema = z.object({
+  email: emailSchema,
+});
+
+/**
+ * POST /api/auth/email/verify - Verify email with OTP
+ * Uses verifyEmailMethod from auth config to determine verification type:
+ * - 'code': expects email + 6-digit numeric code
+ * - 'link': expects 64-char hex token only
+ */
+export const verifyEmailRequestSchema = z
+  .object({
+    email: emailSchema.optional(),
+    otp: z.string().min(1),
+  })
+  .refine((data) => data.email || data.otp, {
+    message: 'Either email or otp must be provided',
+  });
+
+/**
+ * POST /api/auth/email/send-reset-password - Send reset password email (code or link based on config)
+ */
+export const sendResetPasswordEmailRequestSchema = z.object({
+  email: emailSchema,
+});
+
+/**
+ * POST /api/auth/email/exchange-reset-password-token - Exchange reset password code for reset token
+ * Used in two-step password reset flow (code method only): exchange code for token, then reset password with token
+ */
+export const exchangeResetPasswordTokenRequestSchema = z.object({
+  email: emailSchema,
+  code: z.string().min(1),
+});
+
+/**
+ * POST /api/auth/email/reset-password - Reset password with token
+ * Token can be:
+ * - Magic link token (from send-reset-password endpoint when method is 'link')
+ * - Reset token (from exchange-reset-password-token endpoint after code verification)
+ * Both use RESET_PASSWORD purpose and are verified the same way
+ */
+export const resetPasswordRequestSchema = z.object({
+  newPassword: passwordSchema,
+  otp: z.string().min(1, 'OTP/token is required'),
+});
+
 // ============================================================================
 // Response schemas
 // ============================================================================
 
 /**
  * Response for POST /api/auth/users
+ * Includes optional redirectTo URL when user is successfully registered and email verification is not required
  */
 export const createUserResponseSchema = z.object({
+  user: userSchema.optional(),
+  accessToken: z.string().nullable(),
+  requireEmailVerification: z.boolean().optional(),
+  redirectTo: z.string().url().optional(),
+});
+
+/**
+ * Response for POST /api/auth/sessions
+ * Includes user and access token, plus optional redirectTo URL for frontend navigation
+ */
+export const createSessionResponseSchema = z.object({
   user: userSchema,
   accessToken: z.string(),
+  redirectTo: z.string().url().optional(),
 });
 
 /**
- * Response for POST /api/auth/sessions
+ * Response for POST /api/auth/email/verify
+ * Includes user and access token, plus optional redirectTo URL for frontend navigation
  */
-export const createSessionResponseSchema = createUserResponseSchema;
+export const verifyEmailResponseSchema = z.object({
+  user: userSchema,
+  accessToken: z.string(),
+  redirectTo: z.string().url().optional(),
+});
+
+/**
+ * Response for POST /api/auth/email/exchange-reset-password-token
+ * Returns reset token that can be used to reset password
+ */
+export const exchangeResetPasswordTokenResponseSchema = z.object({
+  token: z.string(),
+  expiresAt: z.string().datetime(),
+});
+
+/**
+ * Response for POST /api/auth/email/reset-password
+ * Includes success message
+ */
+export const resetPasswordResponseSchema = z.object({
+  message: z.string(),
+});
 
 /**
  * Response for POST /api/auth/admin/sessions
@@ -130,20 +217,30 @@ export const getOauthUrlResponseSchema = z.object({
 /**
  * POST /api/auth/oauth/configs - Create OAuth configuration
  */
-export const createOAuthConfigRequestSchema = oAuthConfigSchema.extend({
-  clientSecret: z.string().optional(),
-});
+export const createOAuthConfigRequestSchema = oAuthConfigSchema
+  .omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+  })
+  .extend({
+    clientSecret: z.string().optional(),
+  });
 
 /**
  * PUT /api/auth/oauth/configs/:provider - Update OAuth configuration
  */
 export const updateOAuthConfigRequestSchema = oAuthConfigSchema
+  .omit({
+    id: true,
+    provider: true,
+    createdAt: true,
+    updatedAt: true,
+  })
   .extend({
     clientSecret: z.string().optional(),
   })
-  .omit({
-    provider: true,
-  });
+  .partial();
 
 /**
  * Response for GET /api/auth/oauth/configs
@@ -153,6 +250,40 @@ export const listOAuthConfigsResponseSchema = z.object({
   count: z.number(),
 });
 
+// ============================================================================
+// Authentication Configuration schemas
+// ============================================================================
+
+/**
+ * PUT /api/auth/config - Update authentication configuration
+ */
+export const updateAuthConfigRequestSchema = authConfigSchema
+  .omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+  })
+  .partial();
+
+/**
+ * Response for GET /api/auth/config
+ */
+export const getAuthConfigResponseSchema = authConfigSchema;
+
+/**
+ * Response for GET /api/auth/public-config - Unified public auth configuration endpoint
+ * Combines OAuth providers and email auth configuration
+ */
+export const getPublicAuthConfigResponseSchema = z.object({
+  oAuthProviders: z.array(oAuthProvidersSchema),
+  ...authConfigSchema.omit({
+    id: true,
+    updatedAt: true,
+    createdAt: true,
+    signInRedirectTo: true,
+  }).shape,
+});
+
 // ============================================================================
 // Error response schema
 // ============================================================================
@@ -179,15 +310,30 @@ export type ListUsersRequest = z.infer<typeof listUsersRequestSchema>;
 export type DeleteUsersRequest = z.infer<typeof deleteUsersRequestSchema>;
 export type CreateOAuthConfigRequest = z.infer<typeof createOAuthConfigRequestSchema>;
 export type UpdateOAuthConfigRequest = z.infer<typeof updateOAuthConfigRequestSchema>;
+export type UpdateAuthConfigRequest = z.infer<typeof updateAuthConfigRequestSchema>;
+export type SendVerificationEmailRequest = z.infer<typeof sendVerificationEmailRequestSchema>;
+export type VerifyEmailRequest = z.infer<typeof verifyEmailRequestSchema>;
+export type SendResetPasswordEmailRequest = z.infer<typeof sendResetPasswordEmailRequestSchema>;
+export type ExchangeResetPasswordTokenRequest = z.infer<
+  typeof exchangeResetPasswordTokenRequestSchema
+>;
+export type ResetPasswordRequest = z.infer<typeof resetPasswordRequestSchema>;
 
 // Response types for type-safe responses
 export type CreateUserResponse = z.infer<typeof createUserResponseSchema>;
 export type CreateSessionResponse = z.infer<typeof createSessionResponseSchema>;
+export type VerifyEmailResponse = z.infer<typeof verifyEmailResponseSchema>;
+export type ExchangeResetPasswordTokenResponse = z.infer<
+  typeof exchangeResetPasswordTokenResponseSchema
+>;
+export type ResetPasswordResponse = z.infer<typeof resetPasswordResponseSchema>;
 export type CreateAdminSessionResponse = z.infer<typeof createAdminSessionResponseSchema>;
 export type GetCurrentSessionResponse = z.infer<typeof getCurrentSessionResponseSchema>;
 export type ListUsersResponse = z.infer<typeof listUsersResponseSchema>;
 export type DeleteUsersResponse = z.infer<typeof deleteUsersResponseSchema>;
 export type GetOauthUrlResponse = z.infer<typeof getOauthUrlResponseSchema>;
 export type ListOAuthConfigsResponse = z.infer<typeof listOAuthConfigsResponseSchema>;
+export type GetAuthConfigResponse = z.infer<typeof getAuthConfigResponseSchema>;
+export type GetPublicAuthConfigResponse = z.infer<typeof getPublicAuthConfigResponseSchema>;
 
 export type AuthErrorResponse = z.infer<typeof authErrorResponseSchema>;

package/shared-schemas/src/auth.schema.ts

@@ -13,10 +13,7 @@ export const userIdSchema = z.string().uuid('Invalid user ID format');
 
 export const emailSchema = z.string().email('Invalid email format').toLowerCase().trim();
 
-export const passwordSchema = z
-  .string()
-  .min(6, 'Password must be at least 6 characters')
-  .max(32, 'Password must be less than 32 characters');
+export const passwordSchema = z.string();
 
 export const nameSchema = z
   .string()
@@ -26,6 +23,8 @@ export const nameSchema = z
 
 export const roleSchema = z.enum(['authenticated', 'project_admin']);
 
+export const verificationMethodSchema = z.enum(['code', 'link']);
+
 // ============================================================================
 // Core entity schemas
 // ============================================================================
@@ -54,7 +53,19 @@ export const userSchema = z.object({
  * OAuth state for redirect handling
  */
 
-export const oAuthProvidersSchema = z.enum(['google', 'github']);
+export const oAuthProvidersSchema = z.enum([
+  'google',
+  'github',
+  'discord',
+  'linkedin',
+  'facebook',
+  'instagram',
+  'tiktok',
+  'apple',
+  'x',
+  'spotify',
+  'microsoft',
+]);
 
 export const oAuthStateSchema = z.object({
   provider: oAuthProvidersSchema,
@@ -63,11 +74,33 @@ export const oAuthStateSchema = z.object({
 
 // OAuth provider configuration schema
 export const oAuthConfigSchema = z.object({
-  provider: z.string(),
+  id: z.string().uuid(),
+  provider: oAuthProvidersSchema,
   clientId: z.string().optional(),
   scopes: z.array(z.string()).optional(),
   redirectUri: z.string().optional(),
   useSharedKey: z.boolean(),
+  createdAt: z.string(), // PostgreSQL timestamp
+  updatedAt: z.string(), // PostgreSQL timestamp
+});
+
+// Email authentication configuration schema
+export const authConfigSchema = z.object({
+  id: z.string().uuid(),
+  requireEmailVerification: z.boolean(),
+  passwordMinLength: z.number().min(4).max(128),
+  requireNumber: z.boolean(),
+  requireLowercase: z.boolean(),
+  requireUppercase: z.boolean(),
+  requireSpecialChar: z.boolean(),
+  verifyEmailMethod: verificationMethodSchema,
+  resetPasswordMethod: verificationMethodSchema,
+  signInRedirectTo: z
+    .union([z.string().url(), z.literal(''), z.null()])
+    .optional()
+    .transform((val) => (val === '' ? null : val)),
+  createdAt: z.string(), // PostgreSQL timestamp
+  updatedAt: z.string(), // PostgreSQL timestamp
 });
 
 /**
@@ -89,6 +122,9 @@ export type UserIdSchema = z.infer<typeof userIdSchema>;
 export type EmailSchema = z.infer<typeof emailSchema>;
 export type PasswordSchema = z.infer<typeof passwordSchema>;
 export type RoleSchema = z.infer<typeof roleSchema>;
+export type VerificationMethodSchema = z.infer<typeof verificationMethodSchema>;
 export type UserSchema = z.infer<typeof userSchema>;
 export type TokenPayloadSchema = z.infer<typeof tokenPayloadSchema>;
 export type OAuthConfigSchema = z.infer<typeof oAuthConfigSchema>;
+export type OAuthProvidersSchema = z.infer<typeof oAuthProvidersSchema>;
+export type AuthConfigSchema = z.infer<typeof authConfigSchema>;

package/shared-schemas/src/cloud-events.schema.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+export const appRouteChangeEventSchema = z.object({
+  type: z.literal('APP_ROUTE_CHANGE'),
+  path: z.string(),
+});
+
+export const authSuccessEventSchema = z.object({
+  type: z.literal('AUTH_SUCCESS'),
+});
+
+export const authErrorEventSchema = z.object({
+  type: z.literal('AUTH_ERROR'),
+  message: z.string(),
+});
+
+export const mcpConnectionStatusEventSchema = z.object({
+  type: z.literal('MCP_CONNECTION_STATUS'),
+  connected: z.boolean(),
+  toolName: z.string(),
+  timestamp: z.union([z.number(), z.string()]),
+});
+
+export const showOnboardingOverlayEventSchema = z.object({
+  type: z.literal('SHOW_ONBOARDING_OVERLAY'),
+});
+
+export const showSettingsOverlayEventSchema = z.object({
+  type: z.literal('SHOW_SETTINGS_OVERLAY'),
+});
+
+export const onboardingSuccessSchema = z.object({
+  type: z.literal('ONBOARDING_SUCCESS'),
+});
+
+export const navigateToUsageSchema = z.object({
+  type: z.literal('NAVIGATE_TO_USAGE'),
+});
+
+export const cloudEventSchema = z.discriminatedUnion('type', [
+  appRouteChangeEventSchema,
+  authSuccessEventSchema,
+  authErrorEventSchema,
+  mcpConnectionStatusEventSchema,
+  showOnboardingOverlayEventSchema,
+  showSettingsOverlayEventSchema,
+  onboardingSuccessSchema,
+  navigateToUsageSchema,
+]);
+
+export type AppRouteChangeEvent = z.infer<typeof appRouteChangeEventSchema>;
+export type AuthSuccessEvent = z.infer<typeof authSuccessEventSchema>;
+export type AuthErrorEvent = z.infer<typeof authErrorEventSchema>;
+export type McpConnectionStatusEvent = z.infer<typeof mcpConnectionStatusEventSchema>;
+export type CloudEvent = z.infer<typeof cloudEventSchema>;
+export type ShowOnboardingOverlayEvent = z.infer<typeof showOnboardingOverlayEventSchema>;
+export type ShowSettingsOverlayEvent = z.infer<typeof showSettingsOverlayEventSchema>;

package/shared-schemas/src/database-api.schema.ts

@@ -79,11 +79,11 @@ export const deleteTableResponse = z.object({
 // Raw SQL Schemas
 export const rawSQLRequestSchema = z.object({
   query: z.string().min(1, 'Query is required'),
-  params: z.array(z.any()).optional(),
+  params: z.array(z.unknown()).optional(),
 });
 
 export const rawSQLResponseSchema = z.object({
-  rows: z.array(z.any()),
+  rows: z.array(z.record(z.string(), z.unknown())),
   rowCount: z.number().nullable(),
   fields: z
     .array(
@@ -160,7 +160,7 @@ export const exportJsonDataSchema = z.object({
           oldTable: z.string().nullable(),
         })
       ),
-      rows: z.array(z.any()).optional(),
+      rows: z.array(z.record(z.string(), z.unknown())).optional(),
       recordCount: z.number().optional(),
     })
   ),

package/shared-schemas/src/database.schema.ts

@@ -57,7 +57,7 @@ export const tableSchema = z.object({
     .min(1, 'Table name cannot be empty')
     .max(64, 'Table name must be less than 64 characters'),
   columns: z.array(columnSchema).min(1, 'At least one column is required'),
-  recordCount: z.number().default(0),
+  recordCount: z.number().optional(),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional(),
 });

package/shared-schemas/src/index.ts

@@ -11,3 +11,4 @@ export * from './logs.schema';
 export * from './logs-api.schema';
 export * from './functions.schema';
 export * from './functions-api.schema';
+export * from './cloud-events.schema';

package/shared-schemas/src/logs-api.schema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { auditLogSchema } from './logs.schema';
+import { auditLogSchema, logSchema } from './logs.schema';
 
 export const getAuditLogsRequestSchema = z.object({
   limit: z.number().default(100),
@@ -41,9 +41,15 @@ export const clearAuditLogsResponseSchema = z.object({
   deleted: z.number(),
 });
 
+export const getLogsResponseSchema = z.object({
+  logs: z.array(logSchema),
+  total: z.number(),
+});
+
 export type GetAuditLogsRequest = z.infer<typeof getAuditLogsRequestSchema>;
 export type GetAuditLogsResponse = z.infer<typeof getAuditLogsResponseSchema>;
 export type GetAuditLogStatsRequest = z.infer<typeof getAuditLogStatsRequestSchema>;
 export type GetAuditLogStatsResponse = z.infer<typeof getAuditLogStatsResponseSchema>;
 export type ClearAuditLogsRequest = z.infer<typeof clearAuditLogsRequestSchema>;
 export type ClearAuditLogsResponse = z.infer<typeof clearAuditLogsResponseSchema>;
+export type GetLogsResponse = z.infer<typeof getLogsResponseSchema>;

package/shared-schemas/src/logs.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 
+// Audit log schemas
 export const auditLogSchema = z.object({
   id: z.string(),
   actor: z.string(),
@@ -12,3 +13,28 @@ export const auditLogSchema = z.object({
 });
 
 export type AuditLogSchema = z.infer<typeof auditLogSchema>;
+
+// System log schemas
+export const logSourceSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  token: z.string(),
+});
+
+export const logSchema = z.object({
+  id: z.string(),
+  eventMessage: z.string(),
+  timestamp: z.string(),
+  body: z.record(z.string(), z.unknown()),
+  source: z.string().optional(),
+});
+
+export const logStatsSchema = z.object({
+  source: z.string(),
+  count: z.number(),
+  lastActivity: z.string(),
+});
+
+export type LogSourceSchema = z.infer<typeof logSourceSchema>;
+export type LogSchema = z.infer<typeof logSchema>;
+export type LogStatsSchema = z.infer<typeof logStatsSchema>;