Files
cal.diy/packages/features/ee/integration-attribute-sync/schemas/zod.test.ts
T
8dbe3848e7 feat: Create Integration Attribute Sync records (#26007)
* Add db schema

* Add `CredentialRepository.findByTeamIdAndSlugs`

* Add enabled app slugs for attribute syncing

* Create repository for `IntegrationAttributeSync`

* Create zod schemas

* Create `AttributeSyncUserRuleOutputMapper`

* Create `IntegrationAttributeSyncService`

* Create DI contianer

* Create trpc endpoints

* Create page

* Include team name in `CredentialRepository.findByTeamIdAndSlugs`

* Update schema and relations

* Update types and schemas

* Add more methods to IntegrationAttributeSyncRepository

* Add more services to `IntegrationAttributeSyncService`
- getById
- Init updateIncludeRulesAndMappings

* Refactor `getTeams.handler` to use repository

* Create `createAttributeSync` trpc endpoint

* Create `updateAttributeSync` trpc endpoint

* Add router to trpc

* Create attribute sync child components

* Pass custom actions to `FormCard`

* Create `IntegrationAttributeSyncCard`

* Pass inital props via server side

* Fix prop

* Only refetch on mutation

* Fixes

* Add form error when duplicate field and attribute combo

* Add `updateTransactionWithRUleAndMappings` logic

* Adjust zod schemas

* Service add `updateIncludeRulesAndMappings`

* Pass orgId from server to component

* Rename types

* Add deleteById method to repository

* Add name to integrationAttributeSync

* Add deleteById method to service

* Rename method

* Add deleteAttributeSync trpc endpoint

* Make the IntegrationAttributeSyncCard a dummy component

* test: add tests for IntegrationAttributeSync feature

Co-Authored-By: [email protected] <[email protected]>

* Move creating a attribute sync record to the service

* Add i18n strings

* Safe select credential in find by id and team

* Fix default credentialId value in form

* Update repository return types

* Add i18n string

* Make credentialId optional for form schema

* Fix label

* Add cascade deletes

* Add verification that syncs belong to org

* Create mapper for repository output

* Type fixes

* Remove old test file

* Pass `attributeOptions` from parent to children

* Infer types from zod schema

* Type fixes

* Type fix

* Clean up

* Add i18n strings

* Remove unused file

* Address feedback

* Add migration file

* Address feedback

* Add validation for new integration values

* Remove unused router

* Move away from z.infer to z.ZodType

* Clean up comments

* Type fix

* Type fixes

* Type fix

* fix: add passthrough to syncFormDataSchema to preserve extra fields

Co-Authored-By: [email protected] <[email protected]>

* fix: remove incorrect test that expected extra fields to pass through syncFormDataSchema

Co-Authored-By: [email protected] <[email protected]>

* Add indexes

* Add aria label

* Address feedback - consistent validation

* Fix import paths for attribute types

* refactor: change attributeSyncRules array to singular attributeSyncRule

The database schema enforces a one-to-one relationship between
IntegrationAttributeSync and AttributeSyncRule (via @unique constraint),
and the UI only supports a single rule. This change makes the TypeScript
type match the database schema and UI behavior.

Changes:
- Update IntegrationAttributeSync interface to use attributeSyncRule: AttributeSyncRule | null
- Update mapper to return singular rule instead of wrapping in array
- Update UI component to access sync.attributeSyncRule directly
- Update IIntegrationAttributeSyncUpdateParams Omit type
- Update tests to use attributeSyncRule: null instead of attributeSyncRules: []

Co-Authored-By: [email protected] <[email protected]>

* feat: implement FeatureOptInService (#25805)

* feat: implement FeatureOptInService WIP

* clean up

* feat: consolidate feature repositories and add updateFeatureForUser

- Implement updateFeatureForUser in FeaturesRepository (similar to updateFeatureForTeam)
- Move getUserFeatureState and getTeamFeatureState from PrismaFeatureOptInRepository to FeaturesRepository
- Update FeatureOptInService to use only FeaturesRepository
- Add setUserFeatureState and setTeamFeatureState methods to FeatureOptInService
- Update _router.ts to remove PrismaFeatureOptInRepository usage
- Remove PrismaFeatureOptInRepository.ts and FeatureOptInRepositoryInterface.ts
- Update features.repository.interface.ts and features.repository.mock.ts
- Add integration tests for updateFeatureForUser, getUserFeatureState, getTeamFeatureState
- Update service.integration-test.ts to use FeaturesRepository

Co-Authored-By: [email protected] <[email protected]>

* refactor: rename updateFeatureForUser to setUserFeatureState

Rename to match the convention used for setTeamFeatureState

Co-Authored-By: [email protected] <[email protected]>

* refactor: return FeatureState type from getUserFeatureState and getTeamFeatureState

* fix integration tests

* clean up logics

* update services and router

* refactor: change getUserFeatureState and getTeamFeatureState to accept featureIds array

- Renamed getUserFeatureState to getUserFeatureStates
- Renamed getTeamFeatureState to getTeamFeatureStates
- Changed parameter from featureId: string to featureIds: string[]
- Changed return type from FeatureState to Record<string, FeatureState>
- Updated FeatureOptInService to use the new batch methods
- Added tests for querying multiple features in a single call
- Optimized listFeaturesForTeam to fetch all feature states in one query

Co-Authored-By: [email protected] <[email protected]>

* feat: add getFeatureStateForTeams for batch querying multiple teams

- Added getFeatureStateForTeams method to query a single feature across multiple teams in one call
- Updated FeatureOptInService.resolveFeatureStateAcrossTeams to use the new batch method
- Replaces N+1 queries with a single database query for team states
- Added comprehensive integration tests for the new method

Co-Authored-By: [email protected] <[email protected]>

* refactor: combine org and team state queries into single call

- Include orgId in the teamIds array passed to getFeatureStateForTeams
- Extract org state and team states from the combined result
- Reduces database queries from 3 to 2 in resolveFeatureStateAcrossTeams

Co-Authored-By: [email protected] <[email protected]>

* refactor: use team.isOrganization and clarify computeEffectiveState comment

Co-Authored-By: [email protected] <[email protected]>

* refactor: use MembershipRepository.findAllByUserId with isOrganization

Co-Authored-By: [email protected] <[email protected]>

* feat: add featureId validation using isOptInFeature type guard

Co-Authored-By: [email protected] <[email protected]>

* less queries

* add fallback value

* fix type error

* move files

* add autoOptInFeatures column

* use autoOptInFeatures flag within FeatureOptInService

* add setUserAutoOptIn and setTeamAutoOptIn

* fix computeEffectiveState logic

* rewrite computeEffectiveState

* clean up integration tests

* clean up in afterEach

* fix type error

* refactor: use FeaturesRepository methods instead of direct Prisma calls

Replace all manual userFeatures and teamFeatures Prisma operations with
the new setUserFeatureState and setTeamFeatureState repository methods.

Changes include:
- Admin handlers (assignFeatureToTeam, unassignFeatureFromTeam)
- Test fixtures and integration tests
- Playwright fixtures
- Development scripts

This ensures consistent feature flag management through the repository
pattern and supports the new tri-state semantics (enabled/disabled/inherit).

Co-Authored-By: [email protected] <[email protected]>

* clean up

* fix the logic

* extract some logic into applyAutoOptIn()

* remove wrong code

* refactor: convert setUserFeatureState and setTeamFeatureState to object params with discriminated union

- Convert multiple positional parameters to single object parameter
- Use discriminated union types: assignedBy required for enabled/disabled, omitted for inherit
- Update all callers across repository, service, handlers, fixtures, and tests

* fix type error

* use Promise.all

* fix

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

* Prevent duplicate field and attribute mappings

* Add validation that attribute belongs to the org

* fix: address Cubic AI review feedback

- Add @@index([credentialId]) to IntegrationAttributeSync model for efficient cascade deletes and credential-based queries (confidence: 9/10)
- Fix translation key from 'credential_required' to 'attribute_sync_credential_required' to match existing locale definition (confidence: 10/10)

Co-Authored-By: [email protected] <[email protected]>

* fix: address remaining cubic review feedback

- RuleBuilder.tsx: Use unique IDs for React keys instead of array index to prevent reconciliation bugs when removing conditions
- updateAttributeSync.handler.ts: Add early organization check before service calls for consistency
- createAttributeSync.handler.ts: Add CredentialNotFoundError class for type-safe error handling instead of string matching
- IntegrationAttributeSyncService.test.ts: Replace expect.fail() with proper Vitest rejects.toSatisfy() pattern

Co-Authored-By: [email protected] <[email protected]>

* Pull test file from main

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: Eunjae Lee <[email protected]>
2026-01-12 22:57:28 +00:00

420 lines
9.9 KiB
TypeScript

import { describe, it, expect } from "vitest";
import {
attributeSyncRuleConditionSchema,
attributeSyncRuleSchema,
syncFormDataSchema,
} from "./zod";
describe("attributeSyncRuleConditionSchema", () => {
describe("team conditions", () => {
it("should validate a valid team condition with equals operator", () => {
const condition = {
identifier: "teamId",
operator: "equals",
value: [1, 2, 3],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(true);
if (result.success) {
expect(result.data).toEqual(condition);
}
});
it("should validate a valid team condition with notEquals operator", () => {
const condition = {
identifier: "teamId",
operator: "notEquals",
value: [5],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(true);
});
it("should validate a valid team condition with in operator", () => {
const condition = {
identifier: "teamId",
operator: "in",
value: [1, 2],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(true);
});
it("should validate a valid team condition with notIn operator", () => {
const condition = {
identifier: "teamId",
operator: "notIn",
value: [3, 4],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(true);
});
it("should reject team condition with string values", () => {
const condition = {
identifier: "teamId",
operator: "equals",
value: ["team-1", "team-2"],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(false);
});
it("should reject team condition with invalid operator", () => {
const condition = {
identifier: "teamId",
operator: "contains",
value: [1],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(false);
});
});
describe("attribute conditions", () => {
it("should validate a valid attribute condition with equals operator", () => {
const condition = {
identifier: "attributeId",
attributeId: "attr-123",
operator: "equals",
value: ["option-1", "option-2"],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(true);
if (result.success) {
expect(result.data).toEqual(condition);
}
});
it("should validate a valid attribute condition with in operator", () => {
const condition = {
identifier: "attributeId",
attributeId: "attr-456",
operator: "in",
value: ["opt-a", "opt-b", "opt-c"],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(true);
});
it("should reject attribute condition without attributeId", () => {
const condition = {
identifier: "attributeId",
operator: "equals",
value: ["option-1"],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(false);
});
it("should reject attribute condition with number values", () => {
const condition = {
identifier: "attributeId",
attributeId: "attr-123",
operator: "equals",
value: [1, 2, 3],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(false);
});
});
describe("invalid conditions", () => {
it("should reject condition with invalid identifier", () => {
const condition = {
identifier: "invalidId",
operator: "equals",
value: [1],
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(false);
});
it("should reject condition without value", () => {
const condition = {
identifier: "teamId",
operator: "equals",
};
const result = attributeSyncRuleConditionSchema.safeParse(condition);
expect(result.success).toBe(false);
});
});
});
describe("attributeSyncRuleSchema", () => {
it("should validate a rule with AND operator and team conditions", () => {
const rule = {
operator: "AND",
conditions: [
{
identifier: "teamId",
operator: "equals",
value: [1, 2],
},
],
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(true);
if (result.success) {
expect(result.data).toEqual(rule);
}
});
it("should validate a rule with OR operator and attribute conditions", () => {
const rule = {
operator: "OR",
conditions: [
{
identifier: "attributeId",
attributeId: "attr-1",
operator: "in",
value: ["opt-1"],
},
{
identifier: "attributeId",
attributeId: "attr-2",
operator: "notIn",
value: ["opt-2"],
},
],
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(true);
});
it("should validate a rule with mixed conditions", () => {
const rule = {
operator: "AND",
conditions: [
{
identifier: "teamId",
operator: "equals",
value: [1],
},
{
identifier: "attributeId",
attributeId: "attr-1",
operator: "in",
value: ["opt-1"],
},
],
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(true);
});
it("should validate a rule with empty conditions array", () => {
const rule = {
operator: "AND",
conditions: [],
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(true);
});
it("should reject a rule with invalid operator", () => {
const rule = {
operator: "XOR",
conditions: [],
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(false);
});
it("should reject a rule without operator", () => {
const rule = {
conditions: [],
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(false);
});
it("should reject a rule without conditions", () => {
const rule = {
operator: "AND",
};
const result = attributeSyncRuleSchema.safeParse(rule);
expect(result.success).toBe(false);
});
});
describe("syncFormDataSchema", () => {
const validFormData = {
id: "sync-123",
name: "Test Sync",
credentialId: 1,
enabled: true,
organizationId: 123,
ruleId: "rule-123",
rule: {
operator: "AND",
conditions: [
{
identifier: "teamId",
operator: "equals",
value: [1],
},
],
},
syncFieldMappings: [
{
id: "mapping-1",
integrationFieldName: "field1",
attributeId: "attr-1",
enabled: true,
},
],
};
it("should validate valid form data with existing mappings", () => {
const result = syncFormDataSchema.safeParse(validFormData);
expect(result.success).toBe(true);
if (result.success) {
expect(result.data.id).toBe("sync-123");
expect(result.data.name).toBe("Test Sync");
}
});
it("should validate form data with new mappings (without id)", () => {
const formData = {
...validFormData,
syncFieldMappings: [
{
integrationFieldName: "newField",
attributeId: "attr-new",
enabled: false,
},
],
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(true);
});
it("should validate form data with mixed new and existing mappings", () => {
const formData = {
...validFormData,
syncFieldMappings: [
{
id: "existing-mapping",
integrationFieldName: "existingField",
attributeId: "attr-1",
enabled: true,
},
{
integrationFieldName: "newField",
attributeId: "attr-2",
enabled: false,
},
],
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(true);
});
it("should validate form data with empty mappings array", () => {
const formData = {
...validFormData,
syncFieldMappings: [],
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(true);
});
it("should reject form data with empty name", () => {
const formData = {
...validFormData,
name: "",
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(false);
});
it("should reject form data without required fields", () => {
const formData = {
name: "Test",
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(false);
});
it("should reject form data with invalid rule", () => {
const formData = {
...validFormData,
rule: {
operator: "INVALID",
conditions: [],
},
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(false);
});
it("should reject form data with invalid mapping", () => {
const formData = {
...validFormData,
syncFieldMappings: [
{
integrationFieldName: "field",
// missing attributeId and enabled
},
],
};
const result = syncFormDataSchema.safeParse(formData);
expect(result.success).toBe(false);
});
});