insforge 1.2.10 → 1.4.8

package/frontend/src/lib/utils/utils.ts

@@ -1,183 +1,196 @@
-import { ColumnType } from '@insforge/shared-schemas';
-import { type ClassValue, clsx } from 'clsx';
-import { twMerge } from 'tailwind-merge';
-import { z } from 'zod';
-import { format, parse, isValid, parseISO } from 'date-fns';
-import {
-  uuidSchema,
-  integerSchema,
-  floatSchema,
-  booleanSchema,
-  dateSchema,
-  dateTimeSchema,
-  jsonSchema,
-  stringSchema,
-} from './schemaValidations';
-import { v4 as uuidv4 } from 'uuid';
-import type { ConvertedValue, DisplayValue, ValueConversionResult } from '@/components/datagrid';
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs));
-}
-
-/**
- * Convert and validate a string value based on the specified ColumnType
- */
-export function convertValueForColumn(
-  type: ColumnType | string,
-  value: string | null | undefined
-): ValueConversionResult {
-  try {
-    let convertedValue;
-
-    switch (type) {
-      case ColumnType.UUID:
-        convertedValue = uuidSchema.parse(value);
-        break;
-      case ColumnType.INTEGER:
-        convertedValue = integerSchema.parse(value);
-        break;
-      case ColumnType.FLOAT:
-        convertedValue = floatSchema.parse(value);
-        break;
-      case ColumnType.BOOLEAN:
-        convertedValue = booleanSchema.parse(value);
-        break;
-      case ColumnType.DATE:
-        convertedValue = dateSchema.parse(value);
-        break;
-      case ColumnType.DATETIME:
-        convertedValue = dateTimeSchema.parse(value);
-        break;
-      case ColumnType.JSON:
-        convertedValue = jsonSchema.parse(value);
-        break;
-      case ColumnType.STRING:
-        convertedValue = stringSchema.parse(value);
-        break;
-      default:
-        return {
-          success: false,
-          error: `Unsupported column type: ${type}`,
-        };
-    }
-
-    return {
-      success: true,
-      value: convertedValue,
-    };
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return {
-        success: false,
-        error: error.errors[0]?.message || 'Validation failed',
-      };
-    }
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown conversion error',
-    };
-  }
-}
-
-/**
- * Generate a UUID v4 using the uuid library
- * Works in all browsers and contexts (secure and non-secure)
- * Uses crypto.getRandomValues when available, falls back to Math.random
- */
-export function generateUUID(): string {
-  return uuidv4();
-}
-
-/**
- * Centralized value formatter that handles all data types consistently
- * Converts database values to formatted display strings for UI components
- */
-export function formatValueForDisplay(value: ConvertedValue, type?: ColumnType): DisplayValue {
-  // Handle null/undefined values
-  if (isEmptyValue(value)) {
-    return 'null';
-  }
-
-  // Handle different column types
-  switch (type) {
-    case ColumnType.BOOLEAN:
-      return value ? 'True' : 'False';
-
-    case ColumnType.DATE: {
-      const date = parse(String(value), 'yyyy-MM-dd', new Date());
-      if (!isValid(date)) {
-        return String(value);
-      }
-      const displayValue = format(date, 'MMM dd, yyyy');
-      return displayValue;
-    }
-
-    case ColumnType.DATETIME: {
-      const date = parseISO(String(value));
-      if (!isValid(date)) {
-        return String(value);
-      }
-      const displayValue = format(date, 'MMM dd, yyyy, hh:mm a');
-      return displayValue;
-    }
-
-    case ColumnType.JSON: {
-      try {
-        const parsed = typeof value === 'string' ? JSON.parse(value) : value;
-        const formatted =
-          parsed && typeof parsed === 'object' ? JSON.stringify(parsed) : String(parsed);
-
-        return formatted;
-      } catch {
-        return 'Invalid JSON';
-      }
-    }
-
-    case ColumnType.INTEGER:
-    case ColumnType.FLOAT: {
-      return String(value);
-    }
-
-    case ColumnType.UUID:
-    case ColumnType.STRING:
-    default: {
-      // Convert to string and optionally truncate
-      return String(value);
-    }
-  }
-}
-
-/**
- * Check if a value is considered empty for database purposes
- */
-export function isEmptyValue(value: unknown): boolean {
-  return value === null || value === undefined || value === '';
-}
-
-export const isInsForgeCloudProject = () => {
-  return window.location.hostname.endsWith('.insforge.app');
-};
-
-export const getBackendUrl = () => {
-  const isHttp = window.location.protocol === 'http:';
-  return isHttp ? 'http://localhost:7130' : window.location.origin;
-};
-
-export const isIframe = () => {
-  return window.self !== window.top;
-};
-
-/**
- * Formats a timestamp string to a human-readable format
- * Used consistently across the application for displaying timestamps
- * @param timestamp - ISO timestamp string
- * @returns Formatted date string (e.g., "Jan 15, 2025, 03:30 PM")
- */
-export function formatTime(timestamp: string): string {
-  const date = parseISO(timestamp);
-  if (!isValid(date)) {
-    return timestamp; // Return original if invalid
-  }
-  return format(date, 'MMM dd, yyyy, hh:mm a');
-}
+import { ColumnType } from '@insforge/shared-schemas';
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { z } from 'zod';
+import { format, parse, isValid, parseISO } from 'date-fns';
+import {
+  uuidSchema,
+  integerSchema,
+  floatSchema,
+  booleanSchema,
+  dateSchema,
+  dateTimeSchema,
+  jsonSchema,
+  stringSchema,
+} from './schemaValidations';
+import { v4 as uuidv4 } from 'uuid';
+import type { ConvertedValue, DisplayValue, ValueConversionResult } from '@/components/datagrid';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+/**
+ * Convert and validate a string value based on the specified ColumnType
+ */
+export function convertValueForColumn(
+  type: ColumnType | string,
+  value: string | null | undefined
+): ValueConversionResult {
+  try {
+    let convertedValue;
+
+    switch (type) {
+      case ColumnType.UUID:
+        convertedValue = uuidSchema.parse(value);
+        break;
+      case ColumnType.INTEGER:
+        convertedValue = integerSchema.parse(value);
+        break;
+      case ColumnType.FLOAT:
+        convertedValue = floatSchema.parse(value);
+        break;
+      case ColumnType.BOOLEAN:
+        convertedValue = booleanSchema.parse(value);
+        break;
+      case ColumnType.DATE:
+        convertedValue = dateSchema.parse(value);
+        break;
+      case ColumnType.DATETIME:
+        convertedValue = dateTimeSchema.parse(value);
+        break;
+      case ColumnType.JSON:
+        convertedValue = jsonSchema.parse(value);
+        break;
+      case ColumnType.STRING:
+        convertedValue = stringSchema.parse(value);
+        break;
+      default:
+        return {
+          success: false,
+          error: `Unsupported column type: ${type}`,
+        };
+    }
+
+    return {
+      success: true,
+      value: convertedValue,
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        error: error.errors[0]?.message || 'Validation failed',
+      };
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown conversion error',
+    };
+  }
+}
+
+/**
+ * Generate a UUID v4 using the uuid library
+ * Works in all browsers and contexts (secure and non-secure)
+ * Uses crypto.getRandomValues when available, falls back to Math.random
+ */
+export function generateUUID(): string {
+  return uuidv4();
+}
+
+/**
+ * Centralized value formatter that handles all data types consistently
+ * Converts database values to formatted display strings for UI components
+ */
+export function formatValueForDisplay(value: ConvertedValue, type?: ColumnType): DisplayValue {
+  // Handle null/undefined values
+  if (isEmptyValue(value)) {
+    return 'null';
+  }
+
+  // Handle different column types
+  switch (type) {
+    case ColumnType.BOOLEAN:
+      return value ? 'True' : 'False';
+
+    case ColumnType.DATE: {
+      const date = parse(String(value), 'yyyy-MM-dd', new Date());
+      if (!isValid(date)) {
+        return String(value);
+      }
+      const displayValue = format(date, 'MMM dd, yyyy');
+      return displayValue;
+    }
+
+    case ColumnType.DATETIME: {
+      const date = parseISO(String(value));
+      if (!isValid(date)) {
+        return String(value);
+      }
+      const displayValue = format(date, 'MMM dd, yyyy, hh:mm a');
+      return displayValue;
+    }
+
+    case ColumnType.JSON: {
+      try {
+        const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+        const formatted =
+          parsed && typeof parsed === 'object' ? JSON.stringify(parsed) : String(parsed);
+
+        return formatted;
+      } catch {
+        return 'Invalid JSON';
+      }
+    }
+
+    case ColumnType.INTEGER:
+    case ColumnType.FLOAT: {
+      return String(value);
+    }
+
+    case ColumnType.UUID:
+    case ColumnType.STRING:
+    default: {
+      // Convert to string and optionally truncate
+      return String(value);
+    }
+  }
+}
+
+/**
+ * Check if a value is considered empty for database purposes
+ */
+export function isEmptyValue(value: unknown): boolean {
+  return value === null || value === undefined || value === '';
+}
+
+export const isInsForgeCloudProject = () => {
+  return window.location.hostname.endsWith('.insforge.app');
+};
+
+export const getBackendUrl = () => {
+  const isHttp = window.location.protocol === 'http:';
+  return isHttp ? 'http://localhost:7130' : window.location.origin;
+};
+
+export const isIframe = () => {
+  return window.self !== window.top;
+};
+
+/**
+ * Formats a timestamp string to a human-readable format with time
+ * Used consistently across the application for displaying timestamps
+ * @param timestamp - ISO timestamp string
+ * @returns Formatted date string (e.g., "Jan 15, 2025, 03:30 PM")
+ */
+export function formatTime(timestamp: string): string {
+  const date = parseISO(timestamp);
+  if (!isValid(date)) {
+    return timestamp; // Return original if invalid
+  }
+  return format(date, 'MMM dd, yyyy, hh:mm a');
+}
+
+/**
+ * Formats a timestamp string to a date-only format
+ * @param timestamp - ISO timestamp string
+ * @returns Formatted date string (e.g., "Jan 15, 2025")
+ */
+export function formatDate(timestamp: string): string {
+  const date = parseISO(timestamp);
+  if (!isValid(date)) {
+    return timestamp; // Return original if invalid
+  }
+  return format(date, 'MMM dd, yyyy');
+}

package/frontend/tsconfig.json

@@ -1,26 +1,26 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["./src/*"],
-      "@insforge/shared-schemas": ["../shared-schemas/src/index.ts"],
-    }
-  },
-  "include": ["src", "src/vite-env.d.ts", "../shared-schemas"],
-  "references": [{ "path": "./tsconfig.node.json" }]
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@insforge/shared-schemas": ["../shared-schemas/src/index.ts"],
+    }
+  },
+  "include": ["src", "src/vite-env.d.ts", "../shared-schemas"],
+  "references": [{ "path": "./tsconfig.node.json" }]
 }

package/frontend/tsconfig.node.json

@@ -1,10 +1,10 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["vite.config.ts"]
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
 }

package/functions/deno.json

@@ -1,25 +1,25 @@
-{
-  "compilerOptions": {
-    "lib": ["deno.window", "deno.worker"],
-    "strict": true
-  },
-  "lint": {
-    "files": {
-      "include": ["./**/*.ts", "./**/*.js"]
-    },
-    "rules": {
-      "tags": ["recommended"]
-    }
-  },
-  "fmt": {
-    "files": {
-      "include": ["./**/*.ts", "./**/*.js"]
-    },
-    "options": {
-      "useTabs": false,
-      "lineWidth": 100,
-      "indentWidth": 2,
-      "singleQuote": true
-    }
-  }
+{
+  "compilerOptions": {
+    "lib": ["deno.window", "deno.worker"],
+    "strict": true
+  },
+  "lint": {
+    "files": {
+      "include": ["./**/*.ts", "./**/*.js"]
+    },
+    "rules": {
+      "tags": ["recommended"]
+    }
+  },
+  "fmt": {
+    "files": {
+      "include": ["./**/*.ts", "./**/*.js"]
+    },
+    "options": {
+      "useTabs": false,
+      "lineWidth": 100,
+      "indentWidth": 2,
+      "singleQuote": true
+    }
+  }
 }

package/functions/server.ts

@@ -7,7 +7,7 @@ const port = parseInt(Deno.env.get('PORT') ?? '7133');
 console.log(`Deno serverless runtime running on port ${port}`);
 
 // Configuration
-const WORKER_TIMEOUT_MS = parseInt(Deno.env.get('WORKER_TIMEOUT_MS') ?? '30000');
+const WORKER_TIMEOUT_MS = parseInt(Deno.env.get('WORKER_TIMEOUT_MS') ?? '60000');
 
 // Worker template code - loaded on first use
 let workerTemplateCode: string | null = null;
@@ -76,7 +76,7 @@ async function getFunctionCode(slug: string): Promise<string | null> {
     await client.connect();
 
     const result = await client.queryObject<{ code: string }>`
-      SELECT code FROM _functions 
+      SELECT code FROM functions.definitions
       WHERE slug = ${slug} AND status = 'active'
     `;
 
@@ -107,14 +107,14 @@ async function getFunctionSecrets(): Promise<Record<string, string>> {
       return {};
     }
 
-    // Fetch all active secrets from _secrets table
+    // Fetch all active secrets from system.secrets table
     const result = await client.queryObject<{
       key: string;
       value_ciphertext: string;
     }>`
-      SELECT key, value_ciphertext 
-      FROM _secrets
-      WHERE is_active = true 
+      SELECT key, value_ciphertext
+      FROM system.secrets
+      WHERE is_active = true
         AND (expires_at IS NULL OR expires_at > NOW())
     `;
 

package/functions/worker-template.js

@@ -26,7 +26,7 @@ self.onmessage = async (e) => {
      * - We need to provide Deno.env functionality so functions can access secrets
      *
      * How it works:
-     * 1. The main server (server.ts) fetches all active secrets from the _secrets table
+     * 1. The main server (server.ts) fetches all active secrets from the system.secrets table
      * 2. Only active (is_active=true) and non-expired secrets are included
      * 3. Secrets are decrypted and passed to this worker via the 'secrets' object
      * 4. We create a mock Deno object that provides Deno.env.get()