insforge 0.3.3 → 1.3.0

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

@@ -1,5 +1,13 @@
 import { z } from 'zod';
-import { columnSchema, foreignKeySchema, tableSchema } from './database.schema';
+import {
+  columnSchema,
+  foreignKeySchema,
+  tableSchema,
+  databaseFunctionSchema,
+  databaseIndexSchema,
+  databasePolicySchema,
+  databaseTriggerSchema,
+} from './database.schema';
 
 export const createTableRequestSchema = tableSchema
   .pick({
@@ -79,11 +87,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 +168,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(),
     })
   ),
@@ -257,3 +265,26 @@ export type ImportDatabaseResponse = z.infer<typeof importResponseSchema>;
 // Bulk Upsert Types
 export type BulkUpsertRequest = z.infer<typeof bulkUpsertRequestSchema>;
 export type BulkUpsertResponse = z.infer<typeof bulkUpsertResponseSchema>;
+
+// Database Metadata Response Schemas
+export const databaseFunctionsResponseSchema = z.object({
+  functions: z.array(databaseFunctionSchema),
+});
+
+export const databaseIndexesResponseSchema = z.object({
+  indexes: z.array(databaseIndexSchema),
+});
+
+export const databasePoliciesResponseSchema = z.object({
+  policies: z.array(databasePolicySchema),
+});
+
+export const databaseTriggersResponseSchema = z.object({
+  triggers: z.array(databaseTriggerSchema),
+});
+
+// Database Metadata Response Types
+export type DatabaseFunctionsResponse = z.infer<typeof databaseFunctionsResponseSchema>;
+export type DatabaseIndexesResponse = z.infer<typeof databaseIndexesResponseSchema>;
+export type DatabasePoliciesResponse = z.infer<typeof databasePoliciesResponseSchema>;
+export type DatabaseTriggersResponse = z.infer<typeof databaseTriggersResponseSchema>;

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(),
 });
@@ -67,3 +67,42 @@ export type ColumnSchema = z.infer<typeof columnSchema>;
 export type ForeignKeySchema = z.infer<typeof foreignKeySchema>;
 export type OnUpdateActionSchema = z.infer<typeof onUpdateActionSchema>;
 export type OnDeleteActionSchema = z.infer<typeof onDeleteActionSchema>;
+
+// Database Metadata Object Schemas
+export const databaseFunctionSchema = z.object({
+  functionName: z.string(),
+  functionDef: z.string(),
+  kind: z.string(),
+});
+
+export const databaseIndexSchema = z.object({
+  tableName: z.string(),
+  indexName: z.string(),
+  indexDef: z.string(),
+  isUnique: z.boolean().nullable(),
+  isPrimary: z.boolean().nullable(),
+});
+
+export const databasePolicySchema = z.object({
+  tableName: z.string(),
+  policyName: z.string(),
+  cmd: z.string(),
+  roles: z.array(z.string()),
+  qual: z.string().nullable(),
+  withCheck: z.string().nullable(),
+});
+
+export const databaseTriggerSchema = z.object({
+  tableName: z.string(),
+  triggerName: z.string(),
+  actionTiming: z.string(),
+  eventManipulation: z.string(),
+  actionOrientation: z.string(),
+  actionCondition: z.string().nullable(),
+  actionStatement: z.string(),
+});
+
+export type DatabaseFunction = z.infer<typeof databaseFunctionSchema>;
+export type DatabaseIndex = z.infer<typeof databaseIndexSchema>;
+export type DatabasePolicy = z.infer<typeof databasePolicySchema>;
+export type DatabaseTrigger = z.infer<typeof databaseTriggerSchema>;

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export const docTypeSchema = z
+  .enum([
+    'instructions',
+    'db-sdk',
+    'storage-sdk',
+    'functions-sdk',
+    'ai-integration-sdk',
+    'auth-components-react',
+    'real-time',
+  ])
+  .describe(
+    `
+    Documentation type: 
+      "instructions" (essential backend setup - use FIRST),
+      "db-sdk" (database operations),
+      "storage-sdk" (file storage),
+      "functions-sdk" (edge functions),
+      "auth-components-react" (authentication components for React+Vite applications),
+      "ai-integration-sdk" (AI features),
+      "real-time" (real-time pub/sub through WebSockets)
+    `
+  );
+
+export type DocTypeSchema = z.infer<typeof docTypeSchema>;

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { emailSchema } from './auth.schema';
+
+const emailOrEmails = z.union([
+  emailSchema,
+  z
+    .array(emailSchema)
+    .min(1, 'At least one email is required')
+    .max(50, 'Maximum 50 recipients allowed'),
+]);
+
+export const sendRawEmailRequestSchema = z.object({
+  to: emailOrEmails,
+  subject: z.string().trim().min(1, 'Subject is required').max(500, 'Subject too long'),
+  html: z.string().trim().min(1, 'HTML content is required'),
+  cc: emailOrEmails.optional(),
+  bcc: emailOrEmails.optional(),
+  from: z.string().trim().max(100, 'From name too long').optional(),
+  replyTo: z.string().email('Reply-To must be a valid email').optional(),
+});
+
+export type SendRawEmailRequest = z.infer<typeof sendRawEmailRequestSchema>;
+
+/**
+ * Response for POST /api/email/send-raw
+ * Empty on success - extend with optional fields later if needed
+ */
+export const sendEmailResponseSchema = z.object({});
+
+export type SendEmailResponse = z.infer<typeof sendEmailResponseSchema>;

package/shared-schemas/src/index.ts

@@ -11,3 +11,8 @@ export * from './logs.schema';
 export * from './logs-api.schema';
 export * from './functions.schema';
 export * from './functions-api.schema';
+export * from './cloud-events.schema';
+export * from './realtime.schema';
+export * from './realtime-api.schema';
+export * from './docs.schema';
+export * from './email-api.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>;

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

@@ -1,15 +1,22 @@
 import { z } from 'zod';
 import { storageBucketSchema } from './storage.schema';
 import { oAuthConfigSchema } from './auth.schema';
-import { exportJsonDataSchema } from './database-api.schema';
+import { realtimeChannelSchema } from './realtime.schema';
+import { realtimePermissionsResponseSchema } from './realtime-api.schema';
 
 export const authMetadataSchema = z.object({
   oauths: z.array(oAuthConfigSchema),
 });
 
 export const databaseMetadataSchema = z.object({
-  tables: exportJsonDataSchema.shape.tables,
-  totalSize: z.number(),
+  tables: z.array(
+    z.object({
+      tableName: z.string(),
+      recordCount: z.number(),
+    })
+  ),
+  totalSizeInGB: z.number(),
+  hint: z.string().optional(),
 });
 
 export const bucketMetadataSchema = storageBucketSchema.extend({
@@ -18,7 +25,7 @@ export const bucketMetadataSchema = storageBucketSchema.extend({
 
 export const storageMetadataSchema = z.object({
   buckets: z.array(bucketMetadataSchema),
-  totalSize: z.number(),
+  totalSizeInGB: z.number(),
 });
 
 export const edgeFunctionMetadataSchema = z.object({
@@ -38,12 +45,18 @@ export const aiMetadataSchema = z.object({
   ),
 });
 
+export const realtimeMetadataSchema = z.object({
+  channels: z.array(realtimeChannelSchema),
+  permissions: realtimePermissionsResponseSchema,
+});
+
 export const appMetaDataSchema = z.object({
   auth: authMetadataSchema,
   database: databaseMetadataSchema,
   storage: storageMetadataSchema,
   aiIntegration: aiMetadataSchema.optional(),
   functions: z.array(edgeFunctionMetadataSchema),
+  realtime: realtimeMetadataSchema.optional(),
   version: z.string().optional(),
 });
 
@@ -53,4 +66,5 @@ export type BucketMetadataSchema = z.infer<typeof bucketMetadataSchema>;
 export type StorageMetadataSchema = z.infer<typeof storageMetadataSchema>;
 export type EdgeFunctionMetadataSchema = z.infer<typeof edgeFunctionMetadataSchema>;
 export type AIMetadataSchema = z.infer<typeof aiMetadataSchema>;
+export type RealtimeMetadataSchema = z.infer<typeof realtimeMetadataSchema>;
 export type AppMetadataSchema = z.infer<typeof appMetaDataSchema>;

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

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { realtimeChannelSchema, realtimeMessageSchema } from './realtime.schema';
+
+// ============================================================================
+// Channel CRUD Schemas
+// ============================================================================
+
+// Create Channel
+export const createChannelRequestSchema = z.object({
+  pattern: z.string().min(1, 'Channel pattern is required'),
+  description: z.string().optional(),
+  webhookUrls: z.array(z.string().url()).optional(),
+  enabled: z.boolean().optional().default(true),
+});
+
+export const createChannelResponseSchema = realtimeChannelSchema;
+
+export type CreateChannelRequest = z.infer<typeof createChannelRequestSchema>;
+export type CreateChannelResponse = z.infer<typeof createChannelResponseSchema>;
+
+// Update Channel
+export const updateChannelRequestSchema = z.object({
+  pattern: z.string().min(1).optional(),
+  description: z.string().optional(),
+  webhookUrls: z.array(z.string().url()).optional(),
+  enabled: z.boolean().optional(),
+});
+
+export const updateChannelResponseSchema = realtimeChannelSchema;
+
+export type UpdateChannelRequest = z.infer<typeof updateChannelRequestSchema>;
+export type UpdateChannelResponse = z.infer<typeof updateChannelResponseSchema>;
+
+// Get Channel
+export const getChannelResponseSchema = realtimeChannelSchema;
+
+export type GetChannelResponse = z.infer<typeof getChannelResponseSchema>;
+
+// List Channels
+export const listChannelsResponseSchema = z.array(realtimeChannelSchema);
+
+export type ListChannelsResponse = z.infer<typeof listChannelsResponseSchema>;
+
+// Delete Channel
+export const deleteChannelResponseSchema = z.object({
+  message: z.string(),
+});
+
+export type DeleteChannelResponse = z.infer<typeof deleteChannelResponseSchema>;
+
+// ============================================================================
+// Message Schemas
+// ============================================================================
+
+// List Messages
+export const listMessagesRequestSchema = z.object({
+  channelId: z.string().uuid().optional(),
+  eventName: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(1000).optional().default(100),
+  offset: z.coerce.number().int().min(0).optional().default(0),
+});
+
+export const listMessagesResponseSchema = z.array(realtimeMessageSchema);
+
+export type ListMessagesRequest = z.infer<typeof listMessagesRequestSchema>;
+export type ListMessagesResponse = z.infer<typeof listMessagesResponseSchema>;
+
+// Message Stats
+export const messageStatsRequestSchema = z.object({
+  channelId: z.string().uuid().optional(),
+  since: z.coerce.date().optional(),
+});
+
+export const messageStatsResponseSchema = z.object({
+  totalMessages: z.number().int().min(0),
+  whDeliveryRate: z.number().min(0).max(1),
+  topEvents: z.array(
+    z.object({
+      eventName: z.string(),
+      count: z.number().int().min(0),
+    })
+  ),
+});
+
+export type MessageStatsRequest = z.infer<typeof messageStatsRequestSchema>;
+export type MessageStatsResponse = z.infer<typeof messageStatsResponseSchema>;
+
+// ============================================================================
+// Permissions Schemas
+// ============================================================================
+
+export const rlsPolicySchema = z.object({
+  policyName: z.string(),
+  tableName: z.string(),
+  command: z.string(),
+  roles: z.array(z.string()),
+  using: z.string().nullable(),
+  withCheck: z.string().nullable(),
+});
+
+export const realtimePermissionsResponseSchema = z.object({
+  subscribe: z.object({
+    policies: z.array(rlsPolicySchema),
+  }),
+  publish: z.object({
+    policies: z.array(rlsPolicySchema),
+  }),
+});
+
+export type RlsPolicy = z.infer<typeof rlsPolicySchema>;
+export type RealtimePermissionsResponse = z.infer<typeof realtimePermissionsResponseSchema>;

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

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+
+// ============================================================================
+// Sender Type
+// ============================================================================
+
+export const senderTypeSchema = z.enum(['system', 'user']);
+
+// ============================================================================
+// Channel Schema
+// ============================================================================
+
+export const realtimeChannelSchema = z.object({
+  id: z.string().uuid(),
+  pattern: z.string().min(1),
+  description: z.string().nullable(),
+  webhookUrls: z.array(z.string().url()).nullable(),
+  enabled: z.boolean(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+});
+
+export type RealtimeChannel = z.infer<typeof realtimeChannelSchema>;
+
+// ============================================================================
+// Message Schema
+// ============================================================================
+
+export const realtimeMessageSchema = z.object({
+  id: z.string().uuid(),
+  eventName: z.string().min(1),
+  channelId: z.string().uuid().nullable(),
+  channelName: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()),
+  senderType: senderTypeSchema,
+  senderId: z.string().uuid().nullable(),
+  wsAudienceCount: z.number().int().min(0),
+  whAudienceCount: z.number().int().min(0),
+  whDeliveredCount: z.number().int().min(0),
+  createdAt: z.string().datetime(),
+});
+
+export type RealtimeMessage = z.infer<typeof realtimeMessageSchema>;
+
+// ============================================================================
+// WebSocket Event Payloads (for SDK/frontend)
+// ============================================================================
+
+/**
+ * Payload for realtime:subscribe client event
+ */
+export const subscribeChannelPayloadSchema = z.object({
+  channel: z.string().min(1), // The resolved channel instance, e.g., "order:123"
+});
+
+export type SubscribeChannelPayload = z.infer<typeof subscribeChannelPayloadSchema>;
+
+export const unsubscribeChannelPayloadSchema = z.object({
+  channel: z.string().min(1), // The resolved channel instance, e.g., "order:123"
+});
+
+export type UnsubscribeChannelPayload = z.infer<typeof unsubscribeChannelPayloadSchema>;
+/**
+ * Payload for realtime:publish client event
+ */
+export const publishEventPayloadSchema = z.object({
+  channel: z.string().min(1),
+  event: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()),
+});
+
+export type PublishEventPayload = z.infer<typeof publishEventPayloadSchema>;
+
+/**
+ * Response for subscribe operations (used in Socket.IO ack callbacks)
+ */
+export const subscribeResponseSchema = z.discriminatedUnion('ok', [
+  z.object({
+    ok: z.literal(true),
+    channel: z.string().min(1),
+  }),
+  z.object({
+    ok: z.literal(false),
+    channel: z.string().min(1),
+    error: z.object({
+      code: z.string().min(1),
+      message: z.string().min(1),
+    }),
+  }),
+]);
+
+export type SubscribeResponse = z.infer<typeof subscribeResponseSchema>;
+
+/**
+ * Payload for realtime:error server event (for unsolicited errors like publish failures)
+ */
+export const realtimeErrorPayloadSchema = z.object({
+  channel: z.string().optional(),
+  code: z.string().min(1),
+  message: z.string().min(1),
+});
+
+export type RealtimeErrorPayload = z.infer<typeof realtimeErrorPayloadSchema>;
+
+/**
+ * Payload sent to webhook endpoints
+ */
+export const webhookMessageSchema = z.object({
+  messageId: z.string().uuid(),
+  channel: z.string().min(1),
+  eventName: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()),
+});
+
+export type WebhookMessage = z.infer<typeof webhookMessageSchema>;
+
+// ============================================================================
+// Socket Message Schema
+// ============================================================================
+
+/**
+ * Meta object included in all socket messages
+ */
+export const socketMessageMetaSchema = z.object({
+  channel: z.string().optional(), // Present for room broadcasts
+  messageId: z.string().uuid(),
+  senderType: senderTypeSchema,
+  senderId: z.string().uuid().optional(),
+  timestamp: z.string().datetime(),
+});
+
+export type SocketMessageMeta = z.infer<typeof socketMessageMetaSchema>;
+
+/**
+ * Base socket message schema (meta + passthrough for payload)
+ */
+export const socketMessageSchema = z
+  .object({
+    meta: socketMessageMetaSchema,
+  })
+  .passthrough();
+
+export type SocketMessage = z.infer<typeof socketMessageSchema>;

package/shared-schemas/tsconfig.json

@@ -1,21 +1,21 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": []
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": []
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.json

@@ -1,8 +1,8 @@
-{
-  "files": [],
-  "references": [
-    { "path": "./frontend" },
-    { "path": "./backend" },
-    { "path": "./shared-schemas" }
-  ]
+{
+  "files": [],
+  "references": [
+    { "path": "./frontend" },
+    { "path": "./backend" },
+    { "path": "./shared-schemas" }
+  ]
 }