insforge 0.3.1

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

@@ -0,0 +1,259 @@
+import { z } from 'zod';
+import { columnSchema, foreignKeySchema, tableSchema } from './database.schema';
+
+export const createTableRequestSchema = tableSchema
+  .pick({
+    tableName: true,
+    columns: true,
+  })
+  .extend({
+    rlsEnabled: z.boolean().default(true),
+  });
+
+export const createTableResponseSchema = tableSchema
+  .pick({
+    tableName: true,
+    columns: true,
+  })
+  .extend({
+    message: z.string(),
+    autoFields: z.array(z.string()),
+    nextActions: z.string(),
+  });
+
+export const getTableSchemaResponseSchema = tableSchema;
+
+export const updateTableSchemaRequestSchema = z.object({
+  addColumns: z
+    .array(
+      columnSchema.omit({
+        foreignKey: true,
+      })
+    )
+    .optional(),
+  dropColumns: z.array(z.string()).optional(),
+  updateColumns: z
+    .array(
+      z.object({
+        columnName: z.string(),
+        defaultValue: z.string().optional(),
+        newColumnName: z
+          .string()
+          .min(1, 'New column name cannot be empty')
+          .max(64, 'New column name must be less than 64 characters')
+          .optional(),
+      })
+    )
+    .optional(),
+  addForeignKeys: z
+    .array(
+      z.object({
+        columnName: z.string().min(1, 'Column name is required for adding foreign key'),
+        foreignKey: foreignKeySchema,
+      })
+    )
+    .optional(),
+  dropForeignKeys: z.array(z.string()).optional(),
+  renameTable: z
+    .object({
+      newTableName: z
+        .string()
+        .min(1, 'New table name cannot be empty')
+        .max(64, 'New table name must be less than 64 characters'),
+    })
+    .optional(),
+});
+
+export const updateTableSchemaResponse = z.object({
+  message: z.string(),
+  tableName: z.string(),
+  operations: z.array(z.string()),
+});
+
+export const deleteTableResponse = z.object({
+  message: z.string(),
+  tableName: z.string(),
+  nextActions: z.string(),
+});
+
+// Raw SQL Schemas
+export const rawSQLRequestSchema = z.object({
+  query: z.string().min(1, 'Query is required'),
+  params: z.array(z.any()).optional(),
+});
+
+export const rawSQLResponseSchema = z.object({
+  rows: z.array(z.any()),
+  rowCount: z.number().nullable(),
+  fields: z
+    .array(
+      z.object({
+        name: z.string(),
+        dataTypeID: z.number(),
+      })
+    )
+    .optional(),
+});
+
+// Export Schemas
+export const exportRequestSchema = z.object({
+  tables: z.array(z.string()).optional(),
+  format: z.enum(['sql', 'json']).default('sql'),
+  includeData: z.boolean().default(true),
+  includeFunctions: z.boolean().default(false),
+  includeSequences: z.boolean().default(false),
+  includeViews: z.boolean().default(false),
+  rowLimit: z.number().int().positive().max(10000).default(1000),
+});
+
+export const exportJsonDataSchema = z.object({
+  timestamp: z.string(),
+  tables: z.record(
+    z.string(),
+    z.object({
+      schema: z.array(
+        z.object({
+          columnName: z.string(),
+          dataType: z.string(),
+          characterMaximumLength: z.number().nullable(),
+          isNullable: z.string(),
+          columnDefault: z.string().nullable(),
+        })
+      ),
+      indexes: z.array(
+        z.object({
+          indexname: z.string(),
+          indexdef: z.string(),
+          isUnique: z.boolean().nullable(),
+          isPrimary: z.boolean().nullable(),
+        })
+      ),
+      foreignKeys: z.array(
+        z.object({
+          constraintName: z.string(),
+          columnName: z.string(),
+          foreignTableName: z.string(),
+          foreignColumnName: z.string(),
+          deleteRule: z.string().nullable(),
+          updateRule: z.string().nullable(),
+        })
+      ),
+      rlsEnabled: z.boolean().optional(),
+      policies: z.array(
+        z.object({
+          policyname: z.string(),
+          cmd: z.string(),
+          roles: z.array(z.string()),
+          qual: z.string().nullable(),
+          withCheck: z.string().nullable(),
+        })
+      ),
+      triggers: z.array(
+        z.object({
+          triggerName: z.string(),
+          actionTiming: z.string(),
+          eventManipulation: z.string(),
+          actionOrientation: z.string(),
+          actionCondition: z.string().nullable(),
+          actionStatement: z.string(),
+          newTable: z.string().nullable(),
+          oldTable: z.string().nullable(),
+        })
+      ),
+      rows: z.array(z.any()).optional(),
+      recordCount: z.number().optional(),
+    })
+  ),
+  functions: z.array(
+    z.object({
+      functionName: z.string(),
+      functionDef: z.string(),
+      kind: z.string(),
+    })
+  ),
+  sequences: z.array(
+    z.object({
+      sequenceName: z.string(),
+      startValue: z.string(),
+      increment: z.string(),
+      minValue: z.string().nullable(),
+      maxValue: z.string().nullable(),
+      cycle: z.string(),
+    })
+  ),
+  views: z.array(
+    z.object({
+      viewName: z.string(),
+      definition: z.string(),
+    })
+  ),
+});
+
+export const exportResponseSchema = z.object({
+  format: z.enum(['sql', 'json']),
+  data: z.union([z.string(), exportJsonDataSchema]),
+  timestamp: z.string(),
+});
+
+// Import Schemas
+export const importRequestSchema = z.object({
+  truncate: z
+    .union([
+      z.boolean(),
+      z.string().transform((val) => {
+        if (val === 'true') return true;
+        if (val === 'false') return false;
+        throw new Error('Invalid boolean string');
+      }),
+    ])
+    .default(false),
+});
+
+export const importResponseSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  filename: z.string(),
+  tables: z.array(z.string()),
+  rowsImported: z.number(),
+  fileSize: z.number(),
+});
+
+// Bulk Upsert Schemas
+export const bulkUpsertRequestSchema = z.object({
+  table: z.string().min(1, 'Table name is required'),
+  upsertKey: z.string().optional(),
+  // Note: File handling is done at the API layer via multipart/form-data
+});
+
+export const bulkUpsertResponseSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  table: z.string(),
+  rowsAffected: z.number(),
+  totalRecords: z.number(),
+  filename: z.string(),
+});
+
+export type CreateTableRequest = z.infer<typeof createTableRequestSchema>;
+export type CreateTableResponse = z.infer<typeof createTableResponseSchema>;
+export type GetTableSchemaResponse = z.infer<typeof getTableSchemaResponseSchema>;
+export type UpdateTableSchemaRequest = z.infer<typeof updateTableSchemaRequestSchema>;
+export type UpdateTableSchemaResponse = z.infer<typeof updateTableSchemaResponse>;
+export type DeleteTableResponse = z.infer<typeof deleteTableResponse>;
+
+// Raw SQL Types
+export type RawSQLRequest = z.infer<typeof rawSQLRequestSchema>;
+export type RawSQLResponse = z.infer<typeof rawSQLResponseSchema>;
+
+// Export Types
+export type ExportDatabaseRequest = z.infer<typeof exportRequestSchema>;
+export type ExportDatabaseJsonData = z.infer<typeof exportJsonDataSchema>;
+export type ExportDatabaseResponse = z.infer<typeof exportResponseSchema>;
+
+// Import Types
+export type ImportDatabaseRequest = z.infer<typeof importRequestSchema>;
+export type ImportDatabaseResponse = z.infer<typeof importResponseSchema>;
+
+// Bulk Upsert Types
+export type BulkUpsertRequest = z.infer<typeof bulkUpsertRequestSchema>;
+export type BulkUpsertResponse = z.infer<typeof bulkUpsertResponseSchema>;

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+export enum ColumnType {
+  STRING = 'string',
+  DATE = 'date',
+  DATETIME = 'datetime',
+  INTEGER = 'integer',
+  FLOAT = 'float',
+  BOOLEAN = 'boolean',
+  UUID = 'uuid',
+  JSON = 'json',
+}
+
+export const onUpdateActionSchema = z.enum(['CASCADE', 'RESTRICT', 'NO ACTION']);
+export const onDeleteActionSchema = z.enum([
+  'CASCADE',
+  'SET NULL',
+  'SET DEFAULT',
+  'RESTRICT',
+  'NO ACTION',
+]);
+
+export const columnTypeSchema = z.enum([
+  ColumnType.STRING,
+  ColumnType.DATE,
+  ColumnType.DATETIME,
+  ColumnType.INTEGER,
+  ColumnType.FLOAT,
+  ColumnType.BOOLEAN,
+  ColumnType.UUID,
+  ColumnType.JSON,
+]);
+
+export const foreignKeySchema = z.object({
+  referenceTable: z.string().min(1, 'Target table cannot be empty'),
+  referenceColumn: z.string().min(1, 'Target column cannot be empty'),
+  onDelete: onDeleteActionSchema,
+  onUpdate: onUpdateActionSchema,
+});
+
+export const columnSchema = z.object({
+  columnName: z
+    .string()
+    .min(1, 'Column name cannot be empty')
+    .max(64, 'Column name must be less than 64 characters'),
+  type: z.union([columnTypeSchema, z.string()]),
+  defaultValue: z.string().optional(),
+  isPrimaryKey: z.boolean().optional(),
+  isNullable: z.boolean(),
+  isUnique: z.boolean(),
+  foreignKey: foreignKeySchema.optional(),
+});
+
+export const tableSchema = z.object({
+  tableName: z
+    .string()
+    .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),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type TableSchema = z.infer<typeof tableSchema>;
+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>;

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+export const functionUploadRequestSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  slug: z
+    .string()
+    .regex(
+      /^[a-zA-Z0-9_-]+$/,
+      'Invalid slug format - must be alphanumeric with hyphens or underscores only'
+    )
+    .optional(),
+  code: z.string().min(1),
+  description: z.string().optional(),
+  status: z.enum(['draft', 'active']).optional().default('active'),
+});
+
+export const functionUpdateRequestSchema = 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>;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+// Base function schema
+export const functionSchema = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  code: z.string(),
+  status: z.enum(['draft', 'active']),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  deployedAt: z.string().nullable(),
+});
+
+export type FunctionSchema = z.infer<typeof functionSchema>;

package/shared-schemas/src/index.ts

@@ -0,0 +1,13 @@
+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';

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { auditLogSchema } from './logs.schema';
+
+export const getAuditLogsRequestSchema = z.object({
+  limit: z.number().default(100),
+  offset: z.number().default(0),
+  actor: z.string().optional(),
+  action: z.string().optional(),
+  module: z.string().optional(),
+  startDate: z.string().optional(),
+  endDate: z.string().optional(),
+});
+
+export const getAuditLogsResponseSchema = z.object({
+  data: z.array(auditLogSchema),
+  pagination: z.object({
+    limit: z.number(),
+    offset: z.number(),
+    total: z.number(),
+  }),
+});
+
+export const getAuditLogStatsRequestSchema = z.object({
+  days: z.number().default(7),
+});
+
+export const getAuditLogStatsResponseSchema = z.object({
+  totalLogs: z.number(),
+  uniqueActors: z.number(),
+  uniqueModules: z.number(),
+  actionsByModule: z.record(z.number()),
+  recentActivity: z.array(auditLogSchema),
+});
+
+export const clearAuditLogsRequestSchema = z.object({
+  daysToKeep: z.number().default(90),
+});
+
+export const clearAuditLogsResponseSchema = z.object({
+  message: z.string(),
+  deleted: 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>;

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const auditLogSchema = z.object({
+  id: z.string(),
+  actor: z.string(),
+  action: z.string(),
+  module: z.string(),
+  details: z.record(z.unknown()).nullable(),
+  ipAddress: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export type AuditLogSchema = z.infer<typeof auditLogSchema>;

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

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { storageBucketSchema } from './storage.schema';
+import { oAuthConfigSchema } from './auth.schema';
+import { exportJsonDataSchema } from './database-api.schema';
+
+export const authMetadataSchema = z.object({
+  oauths: z.array(oAuthConfigSchema),
+});
+
+export const databaseMetadataSchema = z.object({
+  tables: exportJsonDataSchema.shape.tables,
+  totalSize: z.number(),
+});
+
+export const bucketMetadataSchema = storageBucketSchema.extend({
+  objectCount: z.number().optional(),
+});
+
+export const storageMetadataSchema = z.object({
+  buckets: z.array(bucketMetadataSchema),
+  totalSize: z.number(),
+});
+
+export const edgeFunctionMetadataSchema = z.object({
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  status: z.string(),
+});
+
+export const aiMetadataSchema = z.object({
+  models: z.array(
+    z.object({
+      inputModality: z.array(z.string()),
+      outputModality: z.array(z.string()),
+      modelId: z.string(),
+    })
+  ),
+});
+
+export const appMetaDataSchema = z.object({
+  auth: authMetadataSchema,
+  database: databaseMetadataSchema,
+  storage: storageMetadataSchema,
+  aiIntegration: aiMetadataSchema.optional(),
+  functions: z.array(edgeFunctionMetadataSchema),
+  version: z.string().optional(),
+});
+
+export type AuthMetadataSchema = z.infer<typeof authMetadataSchema>;
+export type DatabaseMetadataSchema = z.infer<typeof databaseMetadataSchema>;
+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 AppMetadataSchema = z.infer<typeof appMetaDataSchema>;

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { storageFileSchema } from './storage.schema';
+
+export const createBucketRequestSchema = z.object({
+  bucketName: z.string().min(1, 'Bucket name cannot be empty'),
+  isPublic: z.boolean().default(true),
+});
+
+export const updateBucketRequestSchema = z.object({
+  isPublic: z.boolean(),
+});
+
+export const listObjectsResponseSchema = z.object({
+  objects: z.array(storageFileSchema),
+  pagination: z.object({
+    offset: z.number(),
+    limit: z.number(),
+    total: z.number(),
+  }),
+});
+
+// Upload strategy schemas
+export const uploadStrategyRequestSchema = z.object({
+  filename: z.string().min(1, 'Filename cannot be empty'),
+  contentType: z.string().optional(),
+  size: z.number().optional(),
+});
+
+export const uploadStrategyResponseSchema = z.object({
+  method: z.enum(['presigned', 'direct']),
+  uploadUrl: z.string(),
+  fields: z.record(z.string()).optional(),
+  key: z.string(),
+  confirmRequired: z.boolean(),
+  confirmUrl: z.string().optional(),
+  expiresAt: z.date().optional(),
+});
+
+// Download strategy schemas
+export const downloadStrategyRequestSchema = z.object({
+  expiresIn: z.number().optional().default(3600),
+});
+
+export const downloadStrategyResponseSchema = z.object({
+  method: z.enum(['presigned', 'direct']),
+  url: z.string(),
+  expiresAt: z.date().optional(),
+  headers: z.record(z.string()).optional(),
+});
+
+// Confirm upload schema
+export const confirmUploadRequestSchema = z.object({
+  size: z.number(),
+  contentType: z.string().optional(),
+  etag: z.string().optional(),
+});
+
+export type CreateBucketRequest = z.infer<typeof createBucketRequestSchema>;
+export type UpdateBucketRequest = z.infer<typeof updateBucketRequestSchema>;
+export type ListObjectsResponseSchema = z.infer<typeof listObjectsResponseSchema>;
+export type UploadStrategyRequest = z.infer<typeof uploadStrategyRequestSchema>;
+export type UploadStrategyResponse = z.infer<typeof uploadStrategyResponseSchema>;
+export type DownloadStrategyRequest = z.infer<typeof downloadStrategyRequestSchema>;
+export type DownloadStrategyResponse = z.infer<typeof downloadStrategyResponseSchema>;
+export type ConfirmUploadRequest = z.infer<typeof confirmUploadRequestSchema>;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+export const storageFileSchema = z.object({
+  key: z.string(),
+  bucket: z.string(),
+  size: z.number(),
+  mimeType: z.string().optional(),
+  uploadedAt: z.string(),
+  url: z.string(),
+});
+
+export const storageBucketSchema = z.object({
+  name: z.string(),
+  public: z.boolean(),
+  createdAt: z.string(),
+});
+
+export type StorageFileSchema = z.infer<typeof storageFileSchema>;
+export type StorageBucketSchema = z.infer<typeof storageBucketSchema>;

package/shared-schemas/tsconfig.json

@@ -0,0 +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"]
+}

package/tsconfig.json

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