[sync] fix: handle IM config and sandbox effort T3422 T3600

Synced from teableio/teable-ee@0c67aed

Co-authored-by: Aries X <caoxing9@gmail.com>
Co-authored-by: Bieber <artist@teable.io>
Co-authored-by: Boris <boris2code@outlook.com>
Co-authored-by: Jocky-Teable <jocky@teable.ai>
Co-authored-by: Jun Lu <hammond@teable.io>
Co-authored-by: Pengap <penganpingprivte@gmail.com>
Co-authored-by: SkyHuang <sky.huang.fe@gmail.com>
Co-authored-by: Uno <uno@teable.ai>
Co-authored-by: nichenqin <nichenqin@hotmail.com>

Author: 10 people

apps/nestjs-backend/package.json

@@ -123,17 +123,17 @@
     "webpack": "5.91.0"
   },
   "dependencies": {
-    "@ai-sdk/amazon-bedrock": "4.0.69",
-    "@ai-sdk/anthropic": "3.0.50",
-    "@ai-sdk/azure": "3.0.38",
-    "@ai-sdk/cohere": "3.0.22",
-    "@ai-sdk/deepseek": "2.0.21",
-    "@ai-sdk/google": "3.0.34",
-    "@ai-sdk/mistral": "3.0.21",
-    "@ai-sdk/openai": "3.0.37",
-    "@ai-sdk/openai-compatible": "2.0.31",
-    "@ai-sdk/togetherai": "2.0.35",
-    "@ai-sdk/xai": "3.0.60",
+    "@ai-sdk/amazon-bedrock": "4.0.96",
+    "@ai-sdk/anthropic": "3.0.71",
+    "@ai-sdk/azure": "3.0.54",
+    "@ai-sdk/cohere": "3.0.30",
+    "@ai-sdk/deepseek": "2.0.29",
+    "@ai-sdk/google": "3.0.64",
+    "@ai-sdk/mistral": "3.0.30",
+    "@ai-sdk/openai": "3.0.53",
+    "@ai-sdk/openai-compatible": "2.0.41",
+    "@ai-sdk/togetherai": "2.0.45",
+    "@ai-sdk/xai": "3.0.83",
     "@an-epiphany/websocket-json-stream": "1.2.0",
     "@aws-sdk/client-s3": "3.609.0",
     "@aws-sdk/lib-storage": "3.609.0",
@@ -154,7 +154,7 @@
     "@nestjs/swagger": "7.3.0",
     "@nestjs/terminus": "10.2.3",
     "@nestjs/websockets": "10.3.5",
-    "@openrouter/ai-sdk-provider": "2.2.3",
+    "@openrouter/ai-sdk-provider": "2.8.1",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/context-async-hooks": "2.5.0",
     "@opentelemetry/exporter-logs-otlp-http": "0.201.1",
@@ -193,7 +193,7 @@
     "@teable/v2-di": "workspace:*",
     "@teable/v2-import": "workspace:*",
     "@valibot/to-json-schema": "1.3.0",
-    "ai": "6.0.105",
+    "ai": "6.0.168",
     "ajv": "8.12.0",
     "archiver": "7.0.1",
     "axios": "1.7.7",
@@ -241,7 +241,7 @@
     "oauth2orize": "1.12.0",
     "oauth2orize-pkce": "0.1.2",
     "object-sizeof": "2.6.4",
-    "ollama-ai-provider-v2": "3.0.2",
+    "ollama-ai-provider-v2": "3.5.0",
     "p-limit": "3.1.0",
     "papaparse": "5.4.1",
     "passport": "0.7.0",

apps/nestjs-backend/src/cache/types.ts

@@ -36,6 +36,7 @@ export interface ICacheStore {
   [key: `oauth:token-rate:${string}:${string}`]: number;
   [key: `automation:email:rate:${string}:${number}`]: number;
   [key: `automation:email-att:${string}`]: string[];
+  [key: `automation:fail-notify-count:${string}`]: number;
   // Distributed lock keys
   [key: `lock:${string}`]: string;
   [key: `import:result:manifest:${string}`]: {

apps/nestjs-backend/src/db-provider/filter-query/__tests__/invalid-filter-skip.spec.ts

@@ -0,0 +1,306 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import {
+  CellValueType,
+  DateFieldCore,
+  DateFormattingPreset,
+  DriverClient,
+  FieldType,
+  NumberFieldCore,
+  SingleLineTextFieldCore,
+  TimeFormatting,
+} from '@teable/core';
+import type { FieldCore, IFilter } from '@teable/core';
+import knex from 'knex';
+import type { IRecordQueryFilterContext } from '../../../features/record/query-builder/record-query-builder.interface';
+import type { IDbProvider } from '../../db.provider.interface';
+import type { AbstractCellValueFilter } from '../cell-value-filter.abstract';
+import { AbstractFilterQuery } from '../filter-query.abstract';
+import { FilterQueryPostgres } from '../postgres/filter-query.postgres';
+
+const knexBuilder = knex({ client: 'pg' });
+const dbProviderStub = { driver: DriverClient.Pg } as unknown as IDbProvider;
+const mainTableAlias = 'main_table as main';
+
+function assignBaseField<T extends FieldCore>(
+  field: T,
+  params: {
+    id: string;
+    name?: string;
+    dbFieldName: string;
+    type: FieldType;
+    cellValueType: CellValueType;
+    options: T['options'];
+  }
+): T {
+  field.id = params.id;
+  field.name = params.name ?? params.id;
+  field.dbFieldName = params.dbFieldName;
+  field.type = params.type;
+  field.options = params.options;
+  field.cellValueType = params.cellValueType;
+  field.isMultipleCellValue = false;
+  field.isLookup = false;
+  field.updateDbFieldType();
+  return field;
+}
+
+function createNumberField(id: string, dbFieldName: string): NumberFieldCore {
+  return assignBaseField(new NumberFieldCore(), {
+    id,
+    dbFieldName,
+    type: FieldType.Number,
+    cellValueType: CellValueType.Number,
+    options: NumberFieldCore.defaultOptions(),
+  });
+}
+
+function createTextField(id: string, dbFieldName: string, name?: string): SingleLineTextFieldCore {
+  return assignBaseField(new SingleLineTextFieldCore(), {
+    id,
+    name,
+    dbFieldName,
+    type: FieldType.SingleLineText,
+    cellValueType: CellValueType.String,
+    options: SingleLineTextFieldCore.defaultOptions(),
+  });
+}
+
+function createDateField(id: string, dbFieldName: string): DateFieldCore {
+  const options = DateFieldCore.defaultOptions();
+  options.formatting = {
+    date: DateFormattingPreset.ISO,
+    time: TimeFormatting.None,
+    timeZone: 'UTC',
+  };
+  return assignBaseField(new DateFieldCore(), {
+    id,
+    dbFieldName,
+    type: FieldType.Date,
+    cellValueType: CellValueType.DateTime,
+    options,
+  });
+}
+
+class ThrowingFilterQuery extends AbstractFilterQuery {
+  private createThrowingFilter(): AbstractCellValueFilter {
+    return {
+      compiler: () => {
+        throw new Error('unexpected adapter failure');
+      },
+    } as unknown as AbstractCellValueFilter;
+  }
+
+  booleanFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  numberFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  dateTimeFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  stringFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+
+  jsonFilter(_field: FieldCore, _context?: IRecordQueryFilterContext): AbstractCellValueFilter {
+    return this.createThrowingFilter();
+  }
+}
+
+describe('filter-query invalid filter skip', () => {
+  it('skips filter item with invalid operator instead of throwing', () => {
+    const numberField = createNumberField('fld_num', 'num_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberField.id,
+          operator: 'contains',
+          value: 'whatever',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [numberField.id]: numberField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(qb.toQuery()).not.toContain('num_col');
+  });
+
+  it('preserves valid filter items alongside skipped invalid ones', () => {
+    const numberField = createNumberField('fld_num', 'num_col');
+    const textField = createTextField('fld_text', 'text_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberField.id,
+          operator: 'contains',
+          value: 'whatever',
+        },
+        {
+          fieldId: textField.id,
+          operator: 'contains',
+          value: 'hello',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [numberField.id]: numberField, [textField.id]: textField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    const sql = qb.toQuery();
+    expect(sql).toContain('text_col');
+    expect(sql).not.toContain('num_col');
+  });
+
+  it('keeps filter items keyed by field name when fields map supports name keys', () => {
+    const textField = createTextField('fld_text_name', 'text_name_col', 'Display Name');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: textField.name,
+          operator: 'contains',
+          value: 'hello',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [textField.id]: textField, [textField.name]: textField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(qb.toQuery()).toContain('text_name_col');
+  });
+
+  it('skips filter item with invalid sub-operator mode instead of throwing', () => {
+    const dateField = createDateField('fld_date', 'date_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateField.id,
+          operator: 'isWithIn',
+          value: { mode: 'invalidMode', exactDate: null, timeZone: 'UTC' },
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias);
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [dateField.id]: dateField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(qb.toQuery()).not.toContain('date_col');
+  });
+
+  it('skips filter item whose value shape fails inside the adapter compiler', () => {
+    const dateField = createDateField('fld_date_shape', 'date_shape_col');
+    // value is a string, but isWithIn requires an object { mode, ... }
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: dateField.id,
+          operator: 'isWithIn',
+          value: 'today',
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias).select('id');
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [dateField.id]: dateField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(() => qb.toQuery()).not.toThrow();
+  });
+
+  it('rethrows non-user compiler errors instead of swallowing them', () => {
+    const numberField = createNumberField('fld_num_system', 'num_system_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: numberField.id,
+          operator: 'is',
+          value: 1,
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias).select('id');
+    const filterQuery = new ThrowingFilterQuery(
+      qb,
+      { [numberField.id]: numberField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(() => qb.toQuery()).toThrow();
+  });
+
+  it('rethrows field-reference context errors instead of skipping them', () => {
+    const textField = createTextField('fld_text_ref_context', 'text_ref_context_col');
+    const refField = createTextField('fld_ref_context', 'ref_context_col');
+    const filter = {
+      conjunction: 'and',
+      filterSet: [
+        {
+          fieldId: textField.id,
+          operator: 'is',
+          value: { type: 'field', fieldId: refField.id },
+        },
+      ],
+    } as unknown as IFilter;
+
+    const qb = knexBuilder(mainTableAlias).select('id');
+    const filterQuery = new FilterQueryPostgres(
+      qb,
+      { [textField.id]: textField, [refField.id]: refField },
+      filter,
+      undefined,
+      dbProviderStub
+    );
+
+    expect(() => filterQuery.appendQueryBuilder()).not.toThrow();
+    expect(() => qb.toQuery()).toThrow('not available for reference comparisons');
+  });
+});