fix(tables): close TTL extension gaps

Author: j15z

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-types.test.ts

@@ -3,7 +3,7 @@
  */
 import { describe, expect, it } from 'vitest'
 import type { ColumnDefinition } from '@/lib/table'
-import { columnTypeOptionsForTable } from './column-types'
+import { columnTypeOptionsForTable } from '@/app/workspace/[workspaceId]/tables/[tableId]/components/column-config-sidebar/column-types'
 
 describe('columnTypeOptionsForTable', () => {
   const ttlColumn: ColumnDefinition = { name: 'expires_at', type: 'ttl' }

apps/sim/lib/copilot/generated/tool-catalog-v1.ts

@@ -71,6 +71,7 @@ export interface ToolCatalogEntry {
     | 'load_deployment'
     | 'load_integration_tool'
     | 'load_skill'
+    | 'load_slide_layout'
     | 'manage_credential'
     | 'manage_custom_tool'
     | 'manage_knowledge_base'
@@ -199,6 +200,7 @@ export interface ToolCatalogEntry {
     | 'load_deployment'
     | 'load_integration_tool'
     | 'load_skill'
+    | 'load_slide_layout'
     | 'manage_credential'
     | 'manage_custom_tool'
     | 'manage_knowledge_base'
@@ -3143,6 +3145,24 @@ export const LoadSkill: ToolCatalogEntry = {
   },
 }
 
+export const LoadSlideLayout: ToolCatalogEntry = {
+  id: 'load_slide_layout',
+  name: 'load_slide_layout',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description:
+          "Layout name exactly as it appears in the Layout Library index (e.g. 'metric-cards').",
+      },
+    },
+    required: ['name'],
+  },
+}
+
 export const ManageCredential: ToolCatalogEntry = {
   id: 'manage_credential',
   name: 'manage_credential',
@@ -7044,6 +7064,7 @@ export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
   [LoadDeployment.id]: LoadDeployment,
   [LoadIntegrationTool.id]: LoadIntegrationTool,
   [LoadSkill.id]: LoadSkill,
+  [LoadSlideLayout.id]: LoadSlideLayout,
   [ManageCredential.id]: ManageCredential,
   [ManageCustomTool.id]: ManageCustomTool,
   [ManageKnowledgeBase.id]: ManageKnowledgeBase,

apps/sim/lib/copilot/generated/tool-schemas-v1.ts

@@ -3028,6 +3028,20 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  load_slide_layout: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description:
+            "Layout name exactly as it appears in the Layout Library index (e.g. 'metric-cards').",
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
   manage_credential: {
     parameters: {
       type: 'object',

apps/sim/lib/table/column-types/ttl.ts

@@ -83,6 +83,10 @@ export const ttlColumnType: ColumnTypeDefinition = {
     return seconds === null ? { ok: false } : { ok: true, value: seconds }
   },
 
+  coerceForImport(value, context) {
+    return parseTtlEpochSeconds(value, context) ?? String(value)
+  },
+
   valueForConversion(value, target: ColumnDefinition) {
     if (target.type !== 'date') return value
     return epochSecondsToIso(value) ?? value

apps/sim/lib/table/column-types/types.ts

@@ -167,6 +167,9 @@ export interface ColumnTypeDefinition {
     context?: NormalizeDateCellOptions
   ): CoerceResult
 
+  /** Import-only normalization when invalid raw text must survive for row-level validation. */
+  coerceForImport?(value: unknown, context?: NormalizeDateCellOptions): Exclude<JsonValue, Date>
+
   /** Source-owned normalization applied before checking or rewriting a type conversion. */
   valueForConversion?(value: JsonValue, target: ColumnDefinition): JsonValue
 

apps/sim/lib/table/import.ts

@@ -14,8 +14,7 @@
 import type { Options as CsvParseOptions } from 'csv-parse'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { getColumnId } from '@/lib/table/column-keys'
-import type { ColumnType } from '@/lib/table/column-types'
-import { parseTtlEpochSeconds } from '@/lib/table/column-types/ttl'
+import { type ColumnType, columnTypeById } from '@/lib/table/column-types'
 import { parseCurrencyInput } from '@/lib/table/currency'
 import { type NormalizeDateCellOptions, normalizeDateCellValue } from '@/lib/table/dates'
 import type { ColumnDefinition, RowData, TableSchema } from '@/lib/table/types'
@@ -469,12 +468,11 @@ export function inferSchemaFromCsv(
  * back to the original string when unparseable so that schema validation can
  * reject it with context rather than silently inserting `null`.
  *
- * Deliberately NOT routed through the column-type registry's `coerce`, despite
- * covering the same types. The registry's contract is "coerced or rejected",
- * which the write path turns into `null`; an import instead wants an
- * unparseable date or JSON blob to survive as its raw string so the row-level
- * validation error names the offending value. Unifying the two would silently
- * swap a descriptive import error for a blanked cell.
+ * Deliberately not routed through the registry's ordinary `coerce`: that
+ * contract is "coerced or rejected", while an import needs invalid raw text to
+ * survive so row-level validation can name it. Types with special import
+ * behavior own it through `coerceForImport`; the remaining legacy import
+ * semantics stay here until they can move without changing error behavior.
  */
 export function coerceValue(
   value: unknown,
@@ -483,6 +481,9 @@ export function coerceValue(
 ): string | number | boolean | null | Record<string, unknown> | unknown[] {
   if (value === null || value === undefined || value === '') return null
 
+  const importValue = columnTypeById(colType).coerceForImport?.(value, options)
+  if (importValue !== undefined) return importValue
+
   switch (colType) {
     case 'number': {
       const n = Number(value)
@@ -503,9 +504,6 @@ export function coerceValue(
     case 'date': {
       return normalizeDateCellValue(String(value), options) ?? String(value)
     }
-    case 'ttl': {
-      return parseTtlEpochSeconds(value, options) ?? String(value)
-    }
     case 'json': {
       if (typeof value === 'object') return value as Record<string, unknown> | unknown[]
       try {

apps/sim/lib/table/workflow-groups/service.test.ts

@@ -4,9 +4,10 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { TableDefinition, WorkflowGroup } from '@/lib/table/types'
 
-const { mockWithLockedTable, mockGetTableById } = vi.hoisted(() => ({
+const { mockWithLockedTable, mockGetTableById, mockAssertTableRowTtlEnabled } = vi.hoisted(() => ({
   mockWithLockedTable: vi.fn(),
   mockGetTableById: vi.fn(),
+  mockAssertTableRowTtlEnabled: vi.fn(),
 }))
 
 vi.mock('@/lib/table/service', () => ({
@@ -20,6 +21,9 @@ vi.mock('@/lib/table/mutation-locks', () => ({
 vi.mock('@/lib/table/rows/secret-provenance', () => ({
   updateTableRowsWithDerivedSecretProvenance: vi.fn(),
 }))
+vi.mock('@/lib/table/ttl-availability', () => ({
+  assertTableRowTtlEnabled: mockAssertTableRowTtlEnabled,
+}))
 vi.mock('@/lib/table/workflow-columns', () => ({
   runWorkflowColumn: vi.fn().mockResolvedValue(undefined),
   stripGroupDeps: (schema: unknown) => schema,
@@ -34,7 +38,11 @@ vi.mock('@/lib/table/schema-invariants', () => ({
 }))
 
 import { TABLE_LIMITS } from '@/lib/table/constants'
-import { addWorkflowGroup } from '@/lib/table/workflow-groups/service'
+import {
+  addWorkflowGroup,
+  addWorkflowGroupOutput,
+  updateWorkflowGroup,
+} from '@/lib/table/workflow-groups/service'
 
 function groupAt(index: number): WorkflowGroup {
   return {
@@ -73,6 +81,7 @@ function tableWithGroups(count: number): TableDefinition {
 describe('addWorkflowGroup group ceiling', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mockAssertTableRowTtlEnabled.mockResolvedValue(undefined)
   })
 
   function add(existingGroups: number) {
@@ -108,3 +117,57 @@ describe('addWorkflowGroup group ceiling', () => {
     await expect(add(TABLE_LIMITS.MAX_WORKFLOW_GROUPS_PER_TABLE - 1)).resolves.toBeDefined()
   })
 })
+
+describe('workflow group TTL availability', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockAssertTableRowTtlEnabled.mockRejectedValue(new Error('Expiration columns are not enabled'))
+  })
+
+  it.each([
+    [
+      'group creation',
+      () =>
+        addWorkflowGroup(
+          {
+            tableId: 'table-1',
+            workspaceId: 'workspace-1',
+            group: groupAt(1),
+            outputColumns: [{ name: 'expires_at', type: 'ttl' }],
+          } as Parameters<typeof addWorkflowGroup>[0],
+          'request-1'
+        ),
+    ],
+    [
+      'group update',
+      () =>
+        updateWorkflowGroup(
+          {
+            tableId: 'table-1',
+            workspaceId: 'workspace-1',
+            groupId: 'group-1',
+            newOutputColumns: [{ name: 'expires_at', type: 'ttl' }],
+          } as Parameters<typeof updateWorkflowGroup>[0],
+          'request-1'
+        ),
+    ],
+    [
+      'single output addition',
+      () =>
+        addWorkflowGroupOutput(
+          {
+            tableId: 'table-1',
+            workspaceId: 'workspace-1',
+            groupId: 'group-1',
+            blockId: 'block-1',
+            path: 'expiresAt',
+            resolvedOutput: { workflowId: 'workflow-1', columnType: 'ttl', order: [] },
+          },
+          'request-1'
+        ),
+    ],
+  ])('rejects TTL introduction through %s while disabled', async (_label, introduceTtl) => {
+    await expect(introduceTtl()).rejects.toThrow('Expiration columns are not enabled')
+    expect(mockWithLockedTable).not.toHaveBeenCalled()
+  })
+})

apps/sim/lib/table/workflow-groups/service.ts

@@ -26,6 +26,7 @@ import { stripGroupExecutions } from '@/lib/table/rows/executions'
 import { updateTableRowsWithDerivedSecretProvenance } from '@/lib/table/rows/secret-provenance'
 import { assertValidSchema } from '@/lib/table/schema-invariants'
 import { getTableById, withLockedTable } from '@/lib/table/service'
+import { assertTableRowTtlEnabled } from '@/lib/table/ttl-availability'
 import { setTableTxTimeouts } from '@/lib/table/tx'
 import type {
   AddWorkflowGroupData,
@@ -132,6 +133,10 @@ export async function addWorkflowGroup(
   data: AddWorkflowGroupData,
   requestId: string
 ): Promise<TableDefinition> {
+  if (data.outputColumns.some((column) => column.type === 'ttl')) {
+    await assertTableRowTtlEnabled()
+  }
+
   const updatedTable = await withLockedTable(
     data.tableId,
     async (table, trx) => {
@@ -258,6 +263,10 @@ export async function updateWorkflowGroup(
   requestId: string
 ): Promise<TableDefinition> {
   const mappingUpdates = data.mappingUpdates ?? []
+  const introducesTtl =
+    data.newOutputColumns?.some((column) => column.type === 'ttl') === true ||
+    data.resolvedMappingTypes?.columns.some((column) => column.type === 'ttl') === true
+  if (introducesTtl) await assertTableRowTtlEnabled()
 
   // Phase 1 (no lock): consume the output types resolved and authorized by the
   // application command. Resolution stays outside the advisory-lock critical
@@ -640,6 +649,8 @@ export async function addWorkflowGroupOutput(
   },
   requestId: string
 ): Promise<TableDefinition> {
+  if (data.resolvedOutput.columnType === 'ttl') await assertTableRowTtlEnabled()
+
   // Phase 1 (no lock): validate the authorized workflow metadata against the
   // group's current workflow. Phase 2 re-validates the same binding under the
   // table lock before applying the mutation.