insforge 1.2.10 → 1.4.8

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

@@ -21,32 +21,38 @@ export const nameSchema = z
   .max(100, 'Name must be less than 100 characters')
   .trim();
 
-export const roleSchema = z.enum(['authenticated', 'project_admin']);
+export const roleSchema = z.enum(['anon', 'authenticated', 'project_admin']);
 
 export const verificationMethodSchema = z.enum(['code', 'link']);
 
+/**
+ * User profile schema with default fields and passthrough for custom fields
+ * Note: Using snake_case for fields as they are stored directly in PostgreSQL JSONB
+ */
+export const profileSchema = z
+  .object({
+    name: z.string().optional(),
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    avatar_url: z.string().url().optional(),
+  })
+  .passthrough();
+
 // ============================================================================
 // Core entity schemas
 // ============================================================================
 
 /**
- * User entity schema - represents the _user table in PostgreSQL
+ * User entity schema - represents the auth.users table in PostgreSQL
  */
 export const userSchema = z.object({
   id: userIdSchema,
   email: emailSchema,
-  name: nameSchema,
   emailVerified: z.boolean(),
-  identities: z
-    .array(
-      z.object({
-        provider: z.string(),
-      })
-    )
-    .optional(),
-  providerType: z.string().optional(),
+  providers: z.array(z.string()).optional(),
   createdAt: z.string(), // PostgreSQL timestamp
   updatedAt: z.string(), // PostgreSQL timestamp
+  profile: profileSchema.nullable(), // User profile data (name, avatar_url, bio, etc.)
+  metadata: z.record(z.unknown()).nullable(), // System metadata (device ID, login IP, etc.)
 });
 
 /**
@@ -123,6 +129,7 @@ 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 ProfileSchema = z.infer<typeof profileSchema>;
 export type UserSchema = z.infer<typeof userSchema>;
 export type TokenPayloadSchema = z.infer<typeof tokenPayloadSchema>;
 export type OAuthConfigSchema = z.infer<typeof oAuthConfigSchema>;

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

@@ -37,6 +37,24 @@ export const navigateToUsageSchema = z.object({
   type: z.literal('NAVIGATE_TO_USAGE'),
 });
 
+export const showContactModalEventSchema = z.object({
+  type: z.literal('SHOW_CONTACT_MODAL'),
+});
+
+export const showConnectOverlayEventSchema = z.object({
+  type: z.literal('SHOW_CONNECT_OVERLAY'),
+});
+
+export const authorizationCodeEventSchema = z.object({
+  type: z.literal('AUTHORIZATION_CODE'),
+  code: z.string(),
+});
+
+export const routeChangeEventSchema = z.object({
+  type: z.literal('ROUTE_CHANGE'),
+  path: z.string(),
+});
+
 export const cloudEventSchema = z.discriminatedUnion('type', [
   appRouteChangeEventSchema,
   authSuccessEventSchema,
@@ -46,6 +64,10 @@ export const cloudEventSchema = z.discriminatedUnion('type', [
   showSettingsOverlayEventSchema,
   onboardingSuccessSchema,
   navigateToUsageSchema,
+  showContactModalEventSchema,
+  showConnectOverlayEventSchema,
+  authorizationCodeEventSchema,
+  routeChangeEventSchema,
 ]);
 
 export type AppRouteChangeEvent = z.infer<typeof appRouteChangeEventSchema>;
@@ -55,3 +77,7 @@ export type McpConnectionStatusEvent = z.infer<typeof mcpConnectionStatusEventSc
 export type CloudEvent = z.infer<typeof cloudEventSchema>;
 export type ShowOnboardingOverlayEvent = z.infer<typeof showOnboardingOverlayEventSchema>;
 export type ShowSettingsOverlayEvent = z.infer<typeof showSettingsOverlayEventSchema>;
+export type ShowContactModalEvent = z.infer<typeof showContactModalEventSchema>;
+export type ShowConnectOverlayEvent = z.infer<typeof showConnectOverlayEventSchema>;
+export type AuthorizationCodeEvent = z.infer<typeof authorizationCodeEventSchema>;
+export type RouteChangeEvent = z.infer<typeof routeChangeEventSchema>;

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({
@@ -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

@@ -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/deployments-api.schema.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { deploymentSchema } from './deployments.schema';
+
+export const projectSettingsSchema = z.object({
+  buildCommand: z.string().nullable().optional(),
+  outputDirectory: z.string().nullable().optional(),
+  installCommand: z.string().nullable().optional(),
+  devCommand: z.string().nullable().optional(),
+  rootDirectory: z.string().nullable().optional(),
+});
+
+export const envVarSchema = z.object({
+  key: z.string(),
+  value: z.string(),
+});
+
+/**
+ * Response from creating a deployment - includes presigned upload info
+ */
+export const createDeploymentResponseSchema = z.object({
+  id: z.string().uuid(),
+  uploadUrl: z.string().url(),
+  uploadFields: z.record(z.string()), // Required for S3 presigned POST (policy, signature, key, etc.)
+});
+
+/**
+ * Request to start a deployment (step 2)
+ * Triggers upload to Vercel and creates the actual deployment
+ */
+export const startDeploymentRequestSchema = z.object({
+  projectSettings: projectSettingsSchema.optional(),
+  envVars: z.array(envVarSchema).optional(),
+  meta: z.record(z.string()).optional(),
+});
+
+/**
+ * Response from starting a deployment
+ */
+export const startDeploymentResponseSchema = deploymentSchema;
+
+export const listDeploymentsResponseSchema = z.object({
+  data: z.array(deploymentSchema),
+  pagination: z.object({
+    limit: z.number(),
+    offset: z.number(),
+    total: z.number(),
+  }),
+});
+
+export type ProjectSettings = z.infer<typeof projectSettingsSchema>;
+export type EnvVar = z.infer<typeof envVarSchema>;
+export type CreateDeploymentResponse = z.infer<typeof createDeploymentResponseSchema>;
+export type StartDeploymentRequest = z.infer<typeof startDeploymentRequestSchema>;
+export type StartDeploymentResponse = z.infer<typeof startDeploymentResponseSchema>;
+export type ListDeploymentsResponse = z.infer<typeof listDeploymentsResponseSchema>;

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+/**
+ * Deployment status enum schema
+ * WAITING -> UPLOADING -> (Vercel statuses: QUEUED/BUILDING/READY/ERROR/CANCELED)
+ */
+export const deploymentStatusSchema = z.enum([
+  'WAITING', // Record created, waiting for client to upload zip to S3
+  'UPLOADING', // Server is downloading from S3 and uploading to Vercel
+  'QUEUED', // Vercel: deployment queued
+  'BUILDING', // Vercel: deployment building
+  'READY', // Vercel: deployment ready
+  'ERROR', // Vercel: deployment failed
+  'CANCELED', // Vercel: deployment canceled
+]);
+
+export type DeploymentStatusType = z.infer<typeof deploymentStatusSchema>;
+
+export const deploymentSchema = z.object({
+  id: z.string().uuid(),
+  providerDeploymentId: z.string().nullable(), // Provider's deployment ID, null until deployment starts
+  provider: z.string(),
+  status: deploymentStatusSchema,
+  url: z.string().nullable(),
+  metadata: z.record(z.unknown()).nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+});
+
+export type DeploymentSchema = z.infer<typeof deploymentSchema>;

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+export const docTypeSchema = z
+  .enum([
+    'instructions',
+    'auth-sdk',
+    'db-sdk',
+    'storage-sdk',
+    'functions-sdk',
+    'ai-integration-sdk',
+    'auth-components-react',
+    'auth-components-nextjs',
+    'real-time',
+    'deployment',
+  ])
+  .describe(
+    `
+    Documentation type:
+      "instructions" (essential backend setup - use FIRST),
+      "db-sdk" (database operations),
+      "storage-sdk" (file storage),
+      "functions-sdk" (edge functions),
+      "auth-sdk" (direct SDK methods for custom auth flows),
+      "auth-components-react" (authentication components for React+Vite applications),
+      "auth-components-nextjs" (authentication components for Next.js applications),
+      "ai-integration-sdk" (AI features),
+      "real-time" (real-time pub/sub through WebSockets),
+      "deployment" (deploy frontend applications via MCP tool)
+    `
+  );
+
+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/functions-api.schema.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
+import { functionSchema } from './functions.schema';
 
-export const functionUploadRequestSchema = z.object({
+export const uploadFunctionRequestSchema = z.object({
   name: z.string().min(1, 'Name is required'),
   slug: z
     .string()
@@ -14,12 +15,20 @@ export const functionUploadRequestSchema = z.object({
   status: z.enum(['draft', 'active']).optional().default('active'),
 });
 
-export const functionUpdateRequestSchema = z.object({
+export const updateFunctionRequestSchema = z.object({
   name: z.string().optional(),
   code: z.string().optional(),
   description: z.string().optional(),
   status: z.enum(['draft', 'active']).optional(),
 });
 
-export type FunctionUploadRequest = z.infer<typeof functionUploadRequestSchema>;
-export type FunctionUpdateRequest = z.infer<typeof functionUpdateRequestSchema>;
+export const listFunctionsResponseSchema = z.object({
+  functions: z.array(functionSchema),
+  runtime: z.object({
+    status: z.enum(['running', 'unavailable']),
+  }),
+});
+
+export type UploadFunctionRequest = z.infer<typeof uploadFunctionRequestSchema>;
+export type UpdateFunctionRequest = z.infer<typeof updateFunctionRequestSchema>;
+export type ListFunctionsResponse = z.infer<typeof listFunctionsResponseSchema>;

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

@@ -7,7 +7,7 @@ export const functionSchema = z.object({
   name: z.string(),
   description: z.string().nullable(),
   code: z.string(),
-  status: z.enum(['draft', 'active']),
+  status: z.enum(['draft', 'active', 'error']),
   createdAt: z.string(),
   updatedAt: z.string(),
   deployedAt: z.string().nullable(),

package/shared-schemas/src/index.ts

@@ -1,14 +1,22 @@
-export * from './database.schema';
-export * from './database-api.schema';
-export * from './storage.schema';
-export * from './storage-api.schema';
-export * from './auth.schema';
-export * from './auth-api.schema';
-export * from './metadata.schema';
-export * from './ai.schema';
-export * from './ai-api.schema';
-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 './database.schema';
+export * from './database-api.schema';
+export * from './secrets.schema';
+export * from './secrets-api.schema';
+export * from './storage.schema';
+export * from './storage-api.schema';
+export * from './auth.schema';
+export * from './auth-api.schema';
+export * from './metadata.schema';
+export * from './ai.schema';
+export * from './ai-api.schema';
+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';
+export * from './deployments.schema';
+export * from './deployments-api.schema';

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 import { storageBucketSchema } from './storage.schema';
-import { oAuthConfigSchema } from './auth.schema';
+import { realtimeChannelSchema } from './realtime.schema';
+import { realtimePermissionsResponseSchema } from './realtime-api.schema';
+import { getPublicAuthConfigResponseSchema } from './auth-api.schema';
 
-export const authMetadataSchema = z.object({
-  oauths: z.array(oAuthConfigSchema),
-});
+export const authMetadataSchema = getPublicAuthConfigResponseSchema;
 
 export const databaseMetadataSchema = z.object({
   tables: z.array(
@@ -43,12 +43,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(),
 });
 
@@ -58,4 +64,33 @@ 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>;
+
+// Database connection schemas
+export const databaseConnectionParametersSchema = z.object({
+  host: z.string(),
+  port: z.number(),
+  database: z.string(),
+  user: z.string(),
+  password: z.string(),
+  sslmode: z.string(),
+});
+
+export const databaseConnectionInfoSchema = z.object({
+  connectionURL: z.string(),
+  parameters: databaseConnectionParametersSchema,
+});
+
+export const databasePasswordInfoSchema = z.object({
+  databasePassword: z.string(),
+});
+
+export const apiKeyResponseSchema = z.object({
+  apiKey: z.string(),
+});
+
+export type DatabaseConnectionParameters = z.infer<typeof databaseConnectionParametersSchema>;
+export type DatabaseConnectionInfo = z.infer<typeof databaseConnectionInfoSchema>;
+export type DatabasePasswordInfo = z.infer<typeof databasePasswordInfoSchema>;
+export type ApiKeyResponse = z.infer<typeof apiKeyResponseSchema>;

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>;