diff --git a/package-lock.json b/package-lock.json index 91c895f89..d28c42b12 100644 --- a/package-lock.json +++ b/package-lock.json @@ -33,6 +33,7 @@ "@types/json-stringify-safe": "^5.0.0", "@typescript-eslint/eslint-plugin": "^7.3.1", "@typescript-eslint/parser": "^7.3.1", + "@vitest/coverage-v8": "^2.1.8", "contentful-sdk-jsdoc": "^3.1.2", "cz-conventional-changelog": "^3.3.0", "es-check": "^7.0.0", @@ -68,7 +69,6 @@ "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==", "dev": true, "license": "Apache-2.0", - "peer": true, "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" @@ -1556,6 +1556,13 @@ "node": ">=6.9.0" } }, + "node_modules/@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "dev": true, + "license": "MIT" + }, "node_modules/@colors/colors": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz", @@ -2567,6 +2574,16 @@ "url": "https://github.com/chalk/wrap-ansi?sponsor=1" } }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, "node_modules/@jest/schemas": { "version": "29.6.3", "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz", @@ -4244,6 +4261,39 @@ "integrity": "sha512-P7mafQXjkrsoyTRppnt0N21udKS9wUmLXHRyP9saLXLHw32j/FgUJ3FscSWgvSqRs4cj7wKZtwqJEvWJ2jbGmA==", "license": "MPL-2.0" }, + "node_modules/@vitest/coverage-v8": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-2.1.8.tgz", + "integrity": "sha512-2Y7BPlKH18mAZYAW1tYByudlCYrQyl5RGvnnDYJKW5tCiO5qg3KSAy3XAxcxKz900a0ZXxWtKrMuZLe3lKBpJw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@ampproject/remapping": "^2.3.0", + "@bcoe/v8-coverage": "^0.2.3", + "debug": "^4.3.7", + "istanbul-lib-coverage": "^3.2.2", + "istanbul-lib-report": "^3.0.1", + "istanbul-lib-source-maps": "^5.0.6", + "istanbul-reports": "^3.1.7", + "magic-string": "^0.30.12", + "magicast": "^0.3.5", + "std-env": "^3.8.0", + "test-exclude": "^7.0.1", + "tinyrainbow": "^1.2.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@vitest/browser": "2.1.8", + "vitest": "2.1.8" + }, + "peerDependenciesMeta": { + "@vitest/browser": { + "optional": true + } + } + }, "node_modules/@vitest/expect": { "version": "2.1.8", "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.8.tgz", @@ -8358,6 +8408,13 @@ "dev": true, "license": "ISC" }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true, + "license": "MIT" + }, "node_modules/html-void-elements": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz", @@ -9171,6 +9228,83 @@ "node": ">=10.13" } }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^4.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-lib-report/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-source-maps": { + "version": "5.0.6", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-5.0.6.tgz", + "integrity": "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.23", + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-reports": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.7.tgz", + "integrity": "sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/jackspeak": { "version": "3.4.3", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", @@ -9794,6 +9928,47 @@ "@jridgewell/sourcemap-codec": "^1.5.0" } }, + "node_modules/magicast": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.3.5.tgz", + "integrity": "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.25.4", + "@babel/types": "^7.25.4", + "source-map-js": "^1.2.0" + } + }, + "node_modules/make-dir": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/make-dir/node_modules/semver": { + "version": "7.7.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.0.tgz", + "integrity": "sha512-DrfFnPzblFmNrIZzg5RzHegbiRWg7KMR7btwi2yjHwx06zsUbO5g613sVwEV7FTwmzJu+Io0lJe2GJ3LxqpvBQ==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, "node_modules/map-obj": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz", @@ -15284,6 +15459,21 @@ "node": ">=10" } }, + "node_modules/test-exclude": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz", + "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==", + "dev": true, + "license": "ISC", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^10.4.1", + "minimatch": "^9.0.4" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/text-extensions": { "version": "2.4.0", "resolved": "https://registry.npmjs.org/text-extensions/-/text-extensions-2.4.0.tgz", diff --git a/package.json b/package.json index a1026b4a9..9489cdc71 100644 --- a/package.json +++ b/package.json @@ -66,23 +66,26 @@ "prettier": "prettier --write '**/*.{jsx,js,ts,tsx}'", "prettier:check": "prettier --check '**/*.{jsx,js,ts,tsx}'", "pretest": "rimraf coverage", - "test": "npm run test:unit && npm run test:integration && npm run lint && npm run test:types", - "test:unit": "vitest --run ./test/unit", - "test:unit:watch": "vitest ./test/unit", - "test:integration": "vitest --run ./test/integration", - "test:integration:watch": "vitest ./test/integration", + "test": "npm run lint && npm run test:cover-unit && npm run test:types && npm run test:cover-integration && npm run test:size", + "test:cover-unit": "npm run test:unit -- --coverage", + "test:cover-integration": "npm run test:integration -- --coverage", + "test:unit": "npx vitest --project unit --run", + "test:types": "npx vitest --project types --run", + "test:unit-watch": "npx vitest --project unit", + "test:integration": "npx vitest --project integration --run --no-file-parallelism", + "test:integration-watch": "npx vitest --project integration --no-file-parallelism", + "test:browser": "npx playwright install && npx vitest --project browser-unit --run && npx vitest --project browser-integration --run", + "test:version": "grep -r \"0.0.0-determined-by-semantic-release\" ./dist > /dev/null && echo \"version 0.0.0-determined-by-semantic-release found in output\" && exit 1 || exit 0", "test:size": "size-limit", "test:demo-projects": "npm run test:demo-node && npm run test:demo-browser", "test:demo-node": "rimraf ./test/output-integration/node/node-modules && npm --prefix ./test/output-integration/node ci && vitest --run ./test/output-integration/node", "test:demo-browser": "rimraf ./test/output-integration/browser/node-modules && npm --prefix ./test/output-integration/browser ci && npm --prefix ./test/output-integration/browser run test", - "test:types": "tsd", "test:prepush": "npm run build && npm run test:unit && npm run test:types", - "prepublishOnly": "export PUBLISH_RUN=true && npm run build && unset PUBLISH_RUN", + "prepublishOnly": "export PUBLISH_RUN=true && npm run build && unset PUBLISH_RUN && npm run test:version", "postpublish": "npm run docs:publish && npm run clean", "semantic-release": "semantic-release", "prepare": "husky", - "precommit": "npm run lint && npm run prettier:check", - "prepush": "npm run test:prepush" + "precommit": "npm run lint && npm run prettier:check" }, "dependencies": { "@contentful/content-source-maps": "^0.11.7", @@ -109,6 +112,7 @@ "@types/json-stringify-safe": "^5.0.0", "@typescript-eslint/eslint-plugin": "^7.3.1", "@typescript-eslint/parser": "^7.3.1", + "@vitest/coverage-v8": "^2.1.8", "contentful-sdk-jsdoc": "^3.1.2", "cz-conventional-changelog": "^3.3.0", "es-check": "^7.0.0", diff --git a/test/types/asset-d.ts b/test/types/asset-d.ts index 5684ec4db..2e1b4b14c 100644 --- a/test/types/asset-d.ts +++ b/test/types/asset-d.ts @@ -1,8 +1,4 @@ -// As tsd does not pick up the global.d.ts located in /lib we -// explicitly reference it here once. -// eslint-disable-next-line @typescript-eslint/triple-slash-reference -/// -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { Asset, @@ -31,75 +27,84 @@ const assetCollectionWithAllLocales = { limit: mocks.numberValue, items: [mocks.localizedAsset], } - -expectAssignable(mocks.assetDetails) -expectAssignable(mocks.assetFile) -expectAssignable(mocks.assetFields) - -expectAssignable>(mocks.asset) -expectAssignable>(mocks.localizedAsset) - -expectAssignable>(mocks.asset) -expectAssignable>(mocks.localizedAsset) - -expectAssignable>(assetCollection) -expectAssignable>(assetCollectionWithAllLocales) - -expectAssignable>(assetCollection) -expectAssignable>(assetCollectionWithAllLocales) - -expectNotAssignable>(mocks.asset) -expectAssignable>(mocks.localizedAsset) - -expectNotAssignable>( - mocks.asset, -) -expectAssignable>( - mocks.localizedAsset, -) - -expectNotAssignable>( - mocks.asset, -) -expectAssignable>( - mocks.localizedAsset, -) - -expectNotAssignable>(assetCollection) -expectAssignable>(assetCollectionWithAllLocales) - -expectNotAssignable>( - assetCollection, -) -expectAssignable>( - assetCollectionWithAllLocales, -) - -expectNotAssignable< - AssetCollection<'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', AssetLocales> ->(assetCollection) -expectAssignable>( - assetCollectionWithAllLocales, -) - -expectAssignable>(mocks.asset) -expectNotAssignable>(mocks.localizedAsset) - -expectAssignable>(mocks.asset) -expectNotAssignable>(mocks.localizedAsset) - -expectAssignable>(mocks.asset) -expectNotAssignable>(mocks.localizedAsset) - -expectAssignable>(assetCollection) -expectNotAssignable>( - assetCollectionWithAllLocales, -) - -expectAssignable>(assetCollection) -expectNotAssignable>(assetCollectionWithAllLocales) - -expectAssignable>(assetCollection) -expectNotAssignable>( - assetCollectionWithAllLocales, -) +test('asset', async () => { + expectTypeOf(mocks.assetDetails) + expectTypeOf(mocks.assetFile) + expectTypeOf(mocks.assetFields) + + expectTypeOf>(mocks.asset) + expectTypeOf>(mocks.localizedAsset) + + expectTypeOf>(mocks.asset) + expectTypeOf>(mocks.localizedAsset) + + expectTypeOf>(assetCollection) + expectTypeOf>(assetCollectionWithAllLocales) + + expectTypeOf>(assetCollection) + expectTypeOf>(assetCollectionWithAllLocales) + + expectTypeOf(mocks.asset).not.toEqualTypeOf>() + expectTypeOf>(mocks.localizedAsset) + + expectTypeOf(mocks.asset).not.toEqualTypeOf< + Asset<'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', AssetLocales> + >() + expectTypeOf>( + mocks.localizedAsset, + ) + + expectTypeOf(mocks.asset).not.toEqualTypeOf< + Asset<'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', AssetLocales> + >() + expectTypeOf>( + mocks.localizedAsset, + ) + + expectTypeOf(assetCollection).not.toEqualTypeOf< + AssetCollection<'WITH_ALL_LOCALES', AssetLocales> + >() + expectTypeOf>(assetCollectionWithAllLocales) + + expectTypeOf(assetCollection).not.toEqualTypeOf< + AssetCollection<'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', AssetLocales> + >() + expectTypeOf>( + assetCollectionWithAllLocales, + ) + + expectTypeOf(assetCollection).not.toEqualTypeOf< + AssetCollection<'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', AssetLocales> + >() + expectTypeOf>( + assetCollectionWithAllLocales, + ) + + expectTypeOf>(mocks.asset) + expectTypeOf(mocks.localizedAsset).not.toEqualTypeOf< + Asset<'WITHOUT_LINK_RESOLUTION', AssetLocales> + >() + + expectTypeOf>(mocks.asset) + expectTypeOf(mocks.localizedAsset).not.toEqualTypeOf>() + + expectTypeOf>(mocks.asset) + expectTypeOf(mocks.localizedAsset).not.toEqualTypeOf< + Asset<'WITHOUT_UNRESOLVABLE_LINKS', AssetLocales> + >() + + expectTypeOf>(assetCollection) + expectTypeOf(assetCollectionWithAllLocales).not.toEqualTypeOf< + AssetCollection<'WITHOUT_LINK_RESOLUTION', AssetLocales> + >() + + expectTypeOf>(assetCollection) + expectTypeOf(assetCollectionWithAllLocales).not.toEqualTypeOf< + AssetCollection + >() + + expectTypeOf>(assetCollection) + expectTypeOf(assetCollectionWithAllLocales).not.toEqualTypeOf< + AssetCollection<'WITHOUT_UNRESOLVABLE_LINKS', AssetLocales> + >() +}) \ No newline at end of file diff --git a/test/types/chain-options.test-d.ts b/test/types/chain-options.test-d.ts index e6f271a19..e10047f50 100644 --- a/test/types/chain-options.test-d.ts +++ b/test/types/chain-options.test-d.ts @@ -1,53 +1,55 @@ -import { expectAssignable, expectNotAssignable, expectNotType, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { ChainOption, ChainOptions } from '../../lib/utils/client-helpers' import { ChainModifiers } from '../../lib' -expectNotAssignable('ANY_STRING') - -expectAssignable({ - withoutLinkResolution: true as boolean, - withAllLocales: true as boolean, - withoutUnresolvableLinks: true as boolean, -}) - -expectType>({ - withoutLinkResolution: false, - withAllLocales: false, - withoutUnresolvableLinks: false, -}) - -expectType>({ - withoutLinkResolution: false, - withAllLocales: false, - withoutUnresolvableLinks: true, -}) - -expectType>({ - withoutLinkResolution: true, - withAllLocales: false, - withoutUnresolvableLinks: false, -}) - -expectType>({ - withoutLinkResolution: false, - withAllLocales: true, - withoutUnresolvableLinks: false, -}) - -expectType>({ - withoutLinkResolution: false, - withAllLocales: true, - withoutUnresolvableLinks: true, -}) - -expectNotType>({ - withoutLinkResolution: false, - withAllLocales: true, - withoutUnresolvableLinks: false, -}) - -expectType>({ - withoutLinkResolution: true, - withAllLocales: true, - withoutUnresolvableLinks: false, -}) +test('chain-options', async () => { + expectTypeOf('ANY_STRING').not.toEqualTypeOf() + + expectTypeOf({ + withoutLinkResolution: true as boolean, + withAllLocales: true as boolean, + withoutUnresolvableLinks: true as boolean, + }) + + expectTypeOf>({ + withoutLinkResolution: false, + withAllLocales: false, + withoutUnresolvableLinks: false, + }) + + expectTypeOf>({ + withoutLinkResolution: false, + withAllLocales: false, + withoutUnresolvableLinks: true, + }) + + expectTypeOf>({ + withoutLinkResolution: true, + withAllLocales: false, + withoutUnresolvableLinks: false, + }) + + expectTypeOf>({ + withoutLinkResolution: false, + withAllLocales: true, + withoutUnresolvableLinks: false, + }) + + expectTypeOf>({ + withoutLinkResolution: false, + withAllLocales: true, + withoutUnresolvableLinks: true, + }) + + expectTypeOf>({ + withoutLinkResolution: false, + withAllLocales: true, + withoutUnresolvableLinks: false, + }) + + expectTypeOf>({ + withoutLinkResolution: true, + withAllLocales: true, + withoutUnresolvableLinks: false, + }) +}) \ No newline at end of file diff --git a/test/types/client/createClient.test-d.ts b/test/types/client/createClient.test-d.ts index 81ba2894f..c02f247ef 100644 --- a/test/types/client/createClient.test-d.ts +++ b/test/types/client/createClient.test-d.ts @@ -1,4 +1,4 @@ -import { expectType } from 'tsd' +import { expectTypeOf, test } from 'vitest' import { ContentfulClientApi, createClient } from '../../../lib' @@ -7,51 +7,57 @@ const CLIENT_OPTIONS = { space: 'spaceId', } -expectType>(createClient(CLIENT_OPTIONS)) - -expectType>( - createClient(CLIENT_OPTIONS).withoutLinkResolution, -) -expectType(createClient(CLIENT_OPTIONS).withoutLinkResolution.withoutLinkResolution) -expectType(createClient(CLIENT_OPTIONS).withoutLinkResolution.withoutUnresolvableLinks) - -expectType>( - createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales, -) -expectType( - createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales.withoutLinkResolution, -) -expectType(createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales.withAllLocales) -expectType( - createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales.withoutLinkResolution, -) - -expectType>( - createClient(CLIENT_OPTIONS).withoutUnresolvableLinks, -) -expectType(createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withoutUnresolvableLinks) -expectType(createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withoutLinkResolution) - -expectType>( - createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales, -) -expectType( - createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales.withoutUnresolvableLinks, -) -expectType( - createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales.withAllLocales, -) -expectType( - createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales.withoutLinkResolution, -) - -expectType>(createClient(CLIENT_OPTIONS).withAllLocales) -expectType(createClient(CLIENT_OPTIONS).withAllLocales.withAllLocales) - -expectType>( - createClient(CLIENT_OPTIONS).withAllLocales.withoutLinkResolution, -) - -expectType>( - createClient(CLIENT_OPTIONS).withAllLocales.withoutUnresolvableLinks, -) +test('createClient', () => { + expectTypeOf>(createClient(CLIENT_OPTIONS)) + + expectTypeOf>( + createClient(CLIENT_OPTIONS).withoutLinkResolution, + ) + expectTypeOf(createClient(CLIENT_OPTIONS).withoutLinkResolution.withoutLinkResolution) + expectTypeOf(createClient(CLIENT_OPTIONS).withoutLinkResolution.withoutUnresolvableLinks) + + expectTypeOf>( + createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales.withoutLinkResolution, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales.withAllLocales, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutLinkResolution.withAllLocales.withoutLinkResolution, + ) + + expectTypeOf>( + createClient(CLIENT_OPTIONS).withoutUnresolvableLinks, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withoutUnresolvableLinks, + ) + expectTypeOf(createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withoutLinkResolution) + + expectTypeOf>( + createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales.withoutUnresolvableLinks, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales.withAllLocales, + ) + expectTypeOf( + createClient(CLIENT_OPTIONS).withoutUnresolvableLinks.withAllLocales.withoutLinkResolution, + ) + + expectTypeOf>(createClient(CLIENT_OPTIONS).withAllLocales) + expectTypeOf(createClient(CLIENT_OPTIONS).withAllLocales.withAllLocales) + + expectTypeOf>( + createClient(CLIENT_OPTIONS).withAllLocales.withoutLinkResolution, + ) + + expectTypeOf>( + createClient(CLIENT_OPTIONS).withAllLocales.withoutUnresolvableLinks, + ) +}) diff --git a/test/types/client/getAssets.test-d.ts b/test/types/client/getAssets.test-d.ts index 3a0e4af7b..96a8db020 100644 --- a/test/types/client/getAssets.test-d.ts +++ b/test/types/client/getAssets.test-d.ts @@ -1,4 +1,4 @@ -import { expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { Asset, AssetCollection, createClient } from '../../../lib' const client = createClient({ @@ -8,14 +8,17 @@ const client = createClient({ type Locale = 'en' -expectType>(await client.getAsset('test')) +test('getAssets', async () => { -expectType>(await client.getAssets()) +expectTypeOf>(await client.getAsset('test')) -expectType>(await client.withAllLocales.getAsset('test')) -expectType>(await client.withAllLocales.getAsset('test')) +expectTypeOf>(await client.getAssets()) -expectType>(await client.withAllLocales.getAssets()) -expectType>( +expectTypeOf>(await client.withAllLocales.getAsset('test')) +expectTypeOf>(await client.withAllLocales.getAsset('test')) + +expectTypeOf>(await client.withAllLocales.getAssets()) +expectTypeOf>( await client.withAllLocales.getAssets(), ) +}) \ No newline at end of file diff --git a/test/types/client/getEntries.test-d.ts b/test/types/client/getEntries.test-d.ts index 40fec8804..00ef6f1ee 100644 --- a/test/types/client/getEntries.test-d.ts +++ b/test/types/client/getEntries.test-d.ts @@ -1,4 +1,4 @@ -import { expectType, expectError } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { createClient, EntryCollection, Entry, EntrySkeletonType } from '../../../lib' const client = createClient({ @@ -26,28 +26,30 @@ type TestEntrySkeleton = EntrySkeletonType type Locale = 'en' +test('getEntries', async () => { + /** * With no extra parameters */ -expectType>(await client.getEntry('entry-id')) +expectTypeOf>(await client.getEntry('entry-id')) -expectType>( +expectTypeOf>( await client.getEntry('entry-id'), ) -expectType>(await client.getEntries()) +expectTypeOf>(await client.getEntries()) -expectType>( +expectTypeOf>( await client.getEntries(), ) -expectType>((await client.getEntries()).includes!.Entry![0]) +expectTypeOf>((await client.getEntries()).includes!.Entry![0]) -expectType>( +expectTypeOf>( await client.getEntries({ content_type: 'content-type-id' }), ) expectError(await client.getEntries({ content_type: 'unexpected' })) -expectType>( +expectTypeOf>( await client.getEntries({ content_type: 'content-type-id', }), @@ -56,118 +58,118 @@ expectType>( /** * Without unresolvable Links */ -expectType>( +expectTypeOf>( await client.withoutUnresolvableLinks.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withoutUnresolvableLinks.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withoutUnresolvableLinks.getEntries(), ) -expectType>( +expectTypeOf>( await client.withoutUnresolvableLinks.getEntries(), ) -expectType>( +expectTypeOf>( (await client.withoutUnresolvableLinks.getEntries()).includes!.Entry![0], ) /** * Without link resolution */ -expectType>( +expectTypeOf>( await client.withoutLinkResolution.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withoutLinkResolution.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withoutLinkResolution.getEntries(), ) -expectType>( +expectTypeOf>( await client.withoutLinkResolution.getEntries(), ) -expectType>( +expectTypeOf>( (await client.withoutLinkResolution.getEntries()).includes!.Entry![0], ) /** * With all Locales */ -expectType>( +expectTypeOf>( await client.withAllLocales.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.getEntries(), ) -expectType>( +expectTypeOf>( await client.withAllLocales.getEntries(), ) -expectType>( +expectTypeOf>( await client.withAllLocales.getEntries(), ) -expectType>( +expectTypeOf>( (await client.withAllLocales.getEntries()).includes!.Entry![0], ) -expectType>( +expectTypeOf>( (await client.withAllLocales.getEntries()).includes!.Entry![0], ) /** * With all Locales and without unresolvable Links */ -expectType>( +expectTypeOf>( await client.withAllLocales.withoutUnresolvableLinks.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutUnresolvableLinks.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutUnresolvableLinks.getEntry( 'entry-id', ), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutUnresolvableLinks.getEntries(), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutUnresolvableLinks.getEntries(), ) -expectType< +expectTypeOf< EntryCollection >(await client.withAllLocales.withoutUnresolvableLinks.getEntries()) -expectType>( +expectTypeOf>( (await client.withAllLocales.withoutUnresolvableLinks.getEntries()).includes! .Entry![0], ) -expectType>( +expectTypeOf>( (await client.withAllLocales.withoutUnresolvableLinks.getEntries()) .includes!.Entry![0], ) @@ -175,35 +177,35 @@ expectType>( +expectTypeOf>( await client.withAllLocales.withoutLinkResolution.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutLinkResolution.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutLinkResolution.getEntry('entry-id'), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutLinkResolution.getEntries(), ) -expectType>( +expectTypeOf>( await client.withAllLocales.withoutLinkResolution.getEntries(), ) -expectType< +expectTypeOf< EntryCollection >(await client.withAllLocales.withoutLinkResolution.getEntries()) -expectType>( +expectTypeOf>( (await client.withAllLocales.withoutLinkResolution.getEntries()).includes!.Entry![0], ) -expectType>( +expectTypeOf>( (await client.withAllLocales.withoutLinkResolution.getEntries()) .includes!.Entry![0], -) +)}) \ No newline at end of file diff --git a/test/types/client/parseEntries.test-d.ts b/test/types/client/parseEntries.test-d.ts index 13df9051d..93ee3938e 100644 --- a/test/types/client/parseEntries.test-d.ts +++ b/test/types/client/parseEntries.test-d.ts @@ -1,4 +1,4 @@ -import { expectType } from 'tsd' +import { expectTypeOf, test } from 'vitest' import { createClient, EntryCollection, @@ -103,55 +103,59 @@ const dataWithAllLocales: EntryCollection< ], } -expectType>(client.parseEntries(data)) -expectType>(client.parseEntries(data)) +test('parseEntries', async () => { + expectTypeOf>(client.parseEntries(data)) + expectTypeOf>(client.parseEntries(data)) -expectType>( - client.withoutUnresolvableLinks.parseEntries(data), -) -expectType>( - client.withoutUnresolvableLinks.parseEntries(data), -) + expectTypeOf>( + client.withoutUnresolvableLinks.parseEntries(data), + ) + expectTypeOf>( + client.withoutUnresolvableLinks.parseEntries(data), + ) -expectType>( - client.withoutLinkResolution.parseEntries(data), -) -expectType>( - client.withoutLinkResolution.parseEntries(data), -) + expectTypeOf>( + client.withoutLinkResolution.parseEntries(data), + ) + expectTypeOf>( + client.withoutLinkResolution.parseEntries(data), + ) -expectType>( - client.withAllLocales.parseEntries(dataWithAllLocales), -) -expectType>( - client.withAllLocales.parseEntries(dataWithAllLocales), -) -expectType>( - client.withAllLocales.parseEntries(dataWithAllLocales), -) + expectTypeOf>( + client.withAllLocales.parseEntries(dataWithAllLocales), + ) + expectTypeOf>( + client.withAllLocales.parseEntries(dataWithAllLocales), + ) + expectTypeOf>( + client.withAllLocales.parseEntries(dataWithAllLocales), + ) -expectType< - EntryCollection ->(client.withAllLocales.withoutUnresolvableLinks.parseEntries(dataWithAllLocales)) -expectType>( - client.withAllLocales.withoutUnresolvableLinks.parseEntries(dataWithAllLocales), -) -expectType< - EntryCollection ->( - client.withAllLocales.withoutUnresolvableLinks.parseEntries( - dataWithAllLocales, - ), -) + expectTypeOf< + EntryCollection + >(client.withAllLocales.withoutUnresolvableLinks.parseEntries(dataWithAllLocales)) + expectTypeOf>( + client.withAllLocales.withoutUnresolvableLinks.parseEntries(dataWithAllLocales), + ) + expectTypeOf< + EntryCollection + >( + client.withAllLocales.withoutUnresolvableLinks.parseEntries( + dataWithAllLocales, + ), + ) -expectType>( - client.withAllLocales.withoutLinkResolution.parseEntries(dataWithAllLocales), -) -expectType>( - client.withAllLocales.withoutLinkResolution.parseEntries(dataWithAllLocales), -) -expectType>( - client.withAllLocales.withoutLinkResolution.parseEntries( - dataWithAllLocales, - ), -) + expectTypeOf< + EntryCollection + >(client.withAllLocales.withoutLinkResolution.parseEntries(dataWithAllLocales)) + expectTypeOf>( + client.withAllLocales.withoutLinkResolution.parseEntries(dataWithAllLocales), + ) + expectTypeOf< + EntryCollection + >( + client.withAllLocales.withoutLinkResolution.parseEntries( + dataWithAllLocales, + ), + ) +}) diff --git a/test/types/entry-d.ts b/test/types/entry-d.ts index cdf48b94c..7f4e11b9d 100644 --- a/test/types/entry-d.ts +++ b/test/types/entry-d.ts @@ -1,538 +1,554 @@ -// As tsd does not pick up the global.d.ts located in /lib we -// explicitly reference it here once. -// eslint-disable-next-line @typescript-eslint/triple-slash-reference -/// -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { Entry, EntrySkeletonType, EntryFieldTypes } from '../../lib' // @ts-ignore import * as mocks from './mocks' -/** - * A simple Entry with generic fields - */ -expectAssignable>>>({ - ...mocks.entryBasics, - fields: { - stringField: mocks.stringValue, - anyRandomFieldName: mocks.numberValue, - }, -}) - -/** - * A simple Entry generic - */ -expectAssignable>>({ - ...mocks.entryBasics, - fields: { - stringField: mocks.stringValue, - }, -}) - -/** - * A simple Entry generic with a referenced fields wildcard - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - referenceField: EntryFieldTypes.EntryLink>> - }> - > ->({ - ...mocks.entryBasics, - fields: { - stringField: mocks.stringValue, - referenceField: { - ...mocks.entryBasics, - fields: {}, +test('entry', async () => { + /** + * A simple Entry with generic fields + */ + expectTypeOf>>>({ + ...mocks.entryBasics, + fields: { + stringField: mocks.stringValue, + anyRandomFieldName: mocks.numberValue, }, - }, -}) - -/** - * EntryWithoutLinkResolution linked entities are all rendered as links - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - entryReferenceField: EntryFieldTypes.EntryLink - multiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - assetReferenceField: EntryFieldTypes.AssetLink - multiAssetReferenceField: EntryFieldTypes.Array - }>, - 'WITHOUT_LINK_RESOLUTION' - > ->( - mocks.getEntry({ - stringField: mocks.stringValue, - entryReferenceField: mocks.entryLink, - multiEntryReferenceField: [mocks.entryLink, mocks.entryLink], - assetReferenceField: mocks.assetLink, - multiAssetReferenceField: [mocks.assetLink, mocks.assetLink], - }), -) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.EntryLink - }>, - 'WITHOUT_LINK_RESOLUTION' - > ->(mocks.getEntry({ referenceField: undefined })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.Array> - }>, - 'WITHOUT_LINK_RESOLUTION' - > ->(mocks.getEntry({ referenceField: [undefined] })) - -expectNotAssignable< - Entry> ->(mocks.getEntry({ referenceField: undefined })) - -expectNotAssignable< - Entry> ->(mocks.getEntry({ referenceField: mocks.asset })) - -expectNotAssignable< - Entry< - EntrySkeletonType< - { referenceField: EntryFieldTypes.Array }, + }) + + /** + * A simple Entry generic + */ + expectTypeOf>>({ + ...mocks.entryBasics, + fields: { + stringField: mocks.stringValue, + }, + }) + + /** + * A simple Entry generic with a referenced fields wildcard + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + referenceField: EntryFieldTypes.EntryLink>> + }> + > + >({ + ...mocks.entryBasics, + fields: { + stringField: mocks.stringValue, + referenceField: { + ...mocks.entryBasics, + fields: {}, + }, + }, + }) + + /** + * EntryWithoutLinkResolution linked entities are all rendered as links + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + entryReferenceField: EntryFieldTypes.EntryLink + multiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + assetReferenceField: EntryFieldTypes.AssetLink + multiAssetReferenceField: EntryFieldTypes.Array + }>, 'WITHOUT_LINK_RESOLUTION' > - > ->(mocks.getEntry({ referenceField: [undefined] })) + >( + mocks.getEntry({ + stringField: mocks.stringValue, + entryReferenceField: mocks.entryLink, + multiEntryReferenceField: [mocks.entryLink, mocks.entryLink], + assetReferenceField: mocks.assetLink, + multiAssetReferenceField: [mocks.assetLink, mocks.assetLink], + }), + ) + + expectTypeOf(mocks.getEntry({ referenceField: undefined })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.EntryLink + }>, + 'WITHOUT_LINK_RESOLUTION' + > + >() -expectNotAssignable< - Entry< - EntrySkeletonType< - { referenceField: EntryFieldTypes.Array }, + expectTypeOf(mocks.getEntry({ referenceField: [undefined] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.Array> + }>, 'WITHOUT_LINK_RESOLUTION' > - > ->(mocks.getEntry({ referenceField: [mocks.asset] })) - -/** - * EntryWithLinkResolutionAndWithUnresolvableLinks referenced entities can be either resolved or unresolved. - * unresolved entities are referenced as links. Fields with multiple references can have resolved and unresolved mixed. - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - resolvableEntryReferenceField: EntryFieldTypes.EntryLink - unresolvableEntryReferenceField: EntryFieldTypes.EntryLink - resolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - mixedMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - resolvableAssetReferenceField: EntryFieldTypes.AssetLink - unresolvableAssetReferenceField: EntryFieldTypes.AssetLink - resolvableMultiAssetReferenceField: EntryFieldTypes.Array - unresolvableMultiAssetReferenceField: EntryFieldTypes.Array - mixedMultiAssetReferenceField: EntryFieldTypes.Array - }>, - undefined - > ->( - mocks.getEntry({ - stringField: mocks.stringValue, - resolvableEntryReferenceField: mocks.entry, - unresolvableEntryReferenceField: mocks.entryLink, - resolvableMultiEntryReferenceField: [mocks.entry], - unresolvableMultiEntryReferenceField: [mocks.entryLink], - mixedMultiEntryReferenceField: [mocks.entry, mocks.entryLink], - resolvableAssetReferenceField: mocks.asset, - unresolvableAssetReferenceField: mocks.assetLink, - resolvableMultiAssetReferenceField: [mocks.asset], - unresolvableMultiAssetReferenceField: [mocks.assetLink], - mixedMultiAssetReferenceField: [mocks.asset, mocks.assetLink], - }), -) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.EntryLink - }>, - undefined - > ->(mocks.getEntry({ referenceField: undefined })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.Array> - }>, - undefined - > ->(mocks.getEntry({ referenceField: [undefined] })) - -expectNotAssignable< - Entry, undefined> ->(mocks.getEntry({ referenceField: undefined })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, - undefined - > ->(mocks.getEntry({ referenceField: [undefined] })) - -/** - * EntryWithAllLocalesAndWithoutLinkResolution All fields are mapped to the given set of locales. - * linked entites are all rendered as links. - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - entryReferenceField: EntryFieldTypes.EntryLink - multiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - assetReferenceField: EntryFieldTypes.AssetLink - multiAssetReferenceField: EntryFieldTypes.Array - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->( - mocks.getEntry({ - stringField: { US: mocks.stringValue, DE: mocks.stringValue }, - entryReferenceField: { DE: mocks.entryLink, US: mocks.entryLink }, - multiEntryReferenceField: { DE: [mocks.entryLink], US: [mocks.entryLink] }, - assetReferenceField: { DE: mocks.assetLink, US: mocks.assetLink }, - multiAssetReferenceField: { DE: [mocks.assetLink], US: [mocks.assetLink] }, - }), -) - -/* links in single reference fields can be undefined because we can’t distinguish between missing translation and missing links */ -expectAssignable< - Entry< - EntrySkeletonType<{ - entryReferenceField: EntryFieldTypes.EntryLink - assetReferenceField: EntryFieldTypes.AssetLink - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->( - mocks.getEntry({ - entryReferenceField: { US: undefined }, - assetReferenceField: { US: undefined }, - }), -) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.EntryLink - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: mocks.localizedEntry } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.Array> - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [undefined] } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.Array> - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [mocks.localizedEntry] } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: mocks.asset } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [undefined] } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [mocks.asset] } })) - -/** - * EntryWithAllLocalesAndWithLinkResolutionAndWithUnresolvableLinks All fields are mapped to the given set of locales. - * linked entities are all rendered as inlined references, or if not resolvable, as links. multi reference fields can have mixed content. - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - resolvableEntryReferenceField: EntryFieldTypes.EntryLink - unresolvableEntryReferenceField: EntryFieldTypes.EntryLink - resolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - mixedMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - resolvableAssetReferenceField: EntryFieldTypes.AssetLink - unresolvableAssetReferenceField: EntryFieldTypes.AssetLink - resolvableMultiAssetReferenceField: EntryFieldTypes.Array - unresolvableMultiAssetReferenceField: EntryFieldTypes.Array - mixedMultiAssetReferenceField: EntryFieldTypes.Array - }>, - 'WITH_ALL_LOCALES', - 'US' | 'DE' - > ->({ - ...mocks.entryBasics, - fields: { - stringField: { US: mocks.stringValue, DE: mocks.stringValue }, - resolvableEntryReferenceField: { DE: mocks.localizedEntry, US: mocks.localizedEntry }, - unresolvableEntryReferenceField: { US: mocks.entryLink, DE: mocks.entryLink }, - resolvableMultiEntryReferenceField: { DE: [mocks.localizedEntry], US: [mocks.localizedEntry] }, - unresolvableMultiEntryReferenceField: { DE: [mocks.entryLink], US: [mocks.entryLink] }, - mixedMultiEntryReferenceField: { - DE: [mocks.localizedEntry, mocks.entryLink], - US: [mocks.localizedEntry, mocks.entryLink], - }, - resolvableAssetReferenceField: { DE: mocks.localizedAsset, US: mocks.localizedAsset }, - unresolvableAssetReferenceField: { US: mocks.assetLink, DE: mocks.assetLink }, - resolvableMultiAssetReferenceField: { DE: [mocks.localizedAsset], US: [mocks.localizedAsset] }, - unresolvableMultiAssetReferenceField: { DE: [mocks.assetLink], US: [mocks.assetLink] }, - mixedMultiAssetReferenceField: { - DE: [mocks.localizedAsset, mocks.assetLink], - US: [mocks.localizedAsset, mocks.assetLink], - }, - }, -}) - -/* links in single reference fields can be undefined because we can’t distinguish between missing translation and missing links */ -expectAssignable< - Entry< - EntrySkeletonType<{ - entryReferenceField: EntryFieldTypes.EntryLink - assetReferenceField: EntryFieldTypes.AssetLink - }>, - 'WITH_ALL_LOCALES', - 'US' | 'DE' - > ->( - mocks.getEntry({ - entryReferenceField: { US: undefined }, - assetReferenceField: { US: undefined }, - }), -) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.EntryLink[] - }>, - 'WITH_ALL_LOCALES', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [undefined] } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink[] }>, - 'WITH_ALL_LOCALES', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [undefined] } })) - -/** - * EntryWithLinkResolutionAndWithoutUnresolvableLinks only resolvable entities are present. - * unresolvable links are completely removed. - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - resolvableEntryReferenceField: EntryFieldTypes.EntryLink - unresolvableEntryReferenceField: EntryFieldTypes.EntryLink - resolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - mixedMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - resolvableAssetReferenceField: EntryFieldTypes.AssetLink - unresolvableAssetReferenceField: EntryFieldTypes.AssetLink - resolvableMultiAssetReferenceField: EntryFieldTypes.Array - unresolvableMultiAssetReferenceField: EntryFieldTypes.Array - mixedMultiAssetReferenceField: EntryFieldTypes.Array - }>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->( - mocks.getEntry({ - stringField: mocks.stringValue, - resolvableEntryReferenceField: mocks.entry, - unresolvableEntryReferenceField: undefined, - resolvableMultiEntryReferenceField: [mocks.entry], - unresolvableMultiEntryReferenceField: [undefined], - mixedMultiEntryReferenceField: [mocks.entry, undefined], - resolvableAssetReferenceField: mocks.asset, - unresolvableAssetReferenceField: undefined, - resolvableMultiAssetReferenceField: [mocks.asset], - unresolvableMultiAssetReferenceField: [undefined], - mixedMultiAssetReferenceField: [mocks.asset, undefined], - }), -) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.EntryLink - }>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.getEntry({ referenceField: mocks.entryLink })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.Array> - }>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.getEntry({ referenceField: [mocks.entryLink] })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.getEntry({ referenceField: mocks.assetLink })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.getEntry({ referenceField: [mocks.assetLink] })) - -/** - * EntryWithAllLocalesAndWithLinkResolutionAndWithoutUnresolvableLinks All unresolvable fields are removed - */ -expectAssignable< - Entry< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Text - resolvableEntryReferenceField: EntryFieldTypes.EntryLink - unresolvableEntryReferenceField: EntryFieldTypes.EntryLink - resolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink - > - unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink + >() + + expectTypeOf(mocks.getEntry({ referenceField: undefined })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }, 'WITHOUT_LINK_RESOLUTION'> + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: mocks.asset })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }, 'WITHOUT_LINK_RESOLUTION'> + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: [undefined] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType< + { referenceField: EntryFieldTypes.Array }, + 'WITHOUT_LINK_RESOLUTION' > - mixedMultiEntryReferenceField: EntryFieldTypes.Array< - EntryFieldTypes.EntryLink + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: [mocks.asset] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType< + { referenceField: EntryFieldTypes.Array }, + 'WITHOUT_LINK_RESOLUTION' > - resolvableAssetReferenceField: EntryFieldTypes.AssetLink - unresolvableAssetReferenceField: EntryFieldTypes.AssetLink - resolvableMultiAssetReferenceField: EntryFieldTypes.Array - unresolvableMultiAssetReferenceField: EntryFieldTypes.Array - mixedMultiAssetReferenceField: EntryFieldTypes.Array - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', - 'US' | 'DE' - > ->( - mocks.getEntry({ - stringField: { US: mocks.stringValue, DE: mocks.stringValue }, - resolvableEntryReferenceField: { US: mocks.localizedEntry, DE: mocks.localizedEntry }, - unresolvableEntryReferenceField: { US: undefined, DE: undefined }, - resolvableMultiEntryReferenceField: { US: [mocks.localizedEntry], DE: [mocks.localizedEntry] }, - unresolvableMultiEntryReferenceField: { US: [undefined], DE: [undefined] }, - mixedMultiEntryReferenceField: { - US: [mocks.localizedEntry, undefined], - DE: [mocks.localizedEntry, undefined], - }, - resolvableAssetReferenceField: { US: mocks.localizedAsset, DE: mocks.localizedAsset }, - unresolvableAssetReferenceField: { US: undefined, DE: undefined }, - resolvableMultiAssetReferenceField: { US: [mocks.localizedAsset], DE: [mocks.localizedAsset] }, - unresolvableMultiAssetReferenceField: { US: [undefined], DE: [undefined] }, - mixedMultiAssetReferenceField: { - US: [mocks.localizedAsset, undefined], - DE: [mocks.localizedAsset, undefined], + > + >() + + /** + * EntryWithLinkResolutionAndWithUnresolvableLinks referenced entities can be either resolved or unresolved. + * unresolved entities are referenced as links. Fields with multiple references can have resolved and unresolved mixed. + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + resolvableEntryReferenceField: EntryFieldTypes.EntryLink + unresolvableEntryReferenceField: EntryFieldTypes.EntryLink + resolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + mixedMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + resolvableAssetReferenceField: EntryFieldTypes.AssetLink + unresolvableAssetReferenceField: EntryFieldTypes.AssetLink + resolvableMultiAssetReferenceField: EntryFieldTypes.Array + unresolvableMultiAssetReferenceField: EntryFieldTypes.Array + mixedMultiAssetReferenceField: EntryFieldTypes.Array + }>, + undefined + > + >( + mocks.getEntry({ + stringField: mocks.stringValue, + resolvableEntryReferenceField: mocks.entry, + unresolvableEntryReferenceField: mocks.entryLink, + resolvableMultiEntryReferenceField: [mocks.entry], + unresolvableMultiEntryReferenceField: [mocks.entryLink], + mixedMultiEntryReferenceField: [mocks.entry, mocks.entryLink], + resolvableAssetReferenceField: mocks.asset, + unresolvableAssetReferenceField: mocks.assetLink, + resolvableMultiAssetReferenceField: [mocks.asset], + unresolvableMultiAssetReferenceField: [mocks.assetLink], + mixedMultiAssetReferenceField: [mocks.asset, mocks.assetLink], + }), + ) + + expectTypeOf(mocks.getEntry({ referenceField: undefined })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.EntryLink + }>, + undefined + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: [undefined] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.Array> + }>, + undefined + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: undefined })).not.toEqualTypeOf< + Entry, undefined> + >() + + expectTypeOf(mocks.getEntry({ referenceField: [undefined] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, + undefined + > + >() + + /** + * EntryWithAllLocalesAndWithoutLinkResolution All fields are mapped to the given set of locales. + * linked entites are all rendered as links. + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + entryReferenceField: EntryFieldTypes.EntryLink + multiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + assetReferenceField: EntryFieldTypes.AssetLink + multiAssetReferenceField: EntryFieldTypes.Array + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >( + mocks.getEntry({ + stringField: { US: mocks.stringValue, DE: mocks.stringValue }, + entryReferenceField: { DE: mocks.entryLink, US: mocks.entryLink }, + multiEntryReferenceField: { DE: [mocks.entryLink], US: [mocks.entryLink] }, + assetReferenceField: { DE: mocks.assetLink, US: mocks.assetLink }, + multiAssetReferenceField: { DE: [mocks.assetLink], US: [mocks.assetLink] }, + }), + ) + + /* links in single reference fields can be undefined because we can’t distinguish between missing translation and missing links */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + entryReferenceField: EntryFieldTypes.EntryLink + assetReferenceField: EntryFieldTypes.AssetLink + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >( + mocks.getEntry({ + entryReferenceField: { US: undefined }, + assetReferenceField: { US: undefined }, + }), + ) + + expectTypeOf(mocks.getEntry({ referenceField: { US: mocks.localizedEntry } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.EntryLink + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: [undefined] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.Array> + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >() + + expectTypeOf( + mocks.getEntry({ referenceField: { US: [mocks.localizedEntry] } }), + ).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.Array> + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: mocks.asset } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: [undefined] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: [mocks.asset] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_LINK_RESOLUTION', + 'US' | 'DE' + > + >() + + /** + * EntryWithAllLocalesAndWithLinkResolutionAndWithUnresolvableLinks All fields are mapped to the given set of locales. + * linked entities are all rendered as inlined references, or if not resolvable, as links. multi reference fields can have mixed content. + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + resolvableEntryReferenceField: EntryFieldTypes.EntryLink + unresolvableEntryReferenceField: EntryFieldTypes.EntryLink + resolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + mixedMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + resolvableAssetReferenceField: EntryFieldTypes.AssetLink + unresolvableAssetReferenceField: EntryFieldTypes.AssetLink + resolvableMultiAssetReferenceField: EntryFieldTypes.Array + unresolvableMultiAssetReferenceField: EntryFieldTypes.Array + mixedMultiAssetReferenceField: EntryFieldTypes.Array + }>, + 'WITH_ALL_LOCALES', + 'US' | 'DE' + > + >({ + ...mocks.entryBasics, + fields: { + stringField: { US: mocks.stringValue, DE: mocks.stringValue }, + resolvableEntryReferenceField: { DE: mocks.localizedEntry, US: mocks.localizedEntry }, + unresolvableEntryReferenceField: { US: mocks.entryLink, DE: mocks.entryLink }, + resolvableMultiEntryReferenceField: { + DE: [mocks.localizedEntry], + US: [mocks.localizedEntry], + }, + unresolvableMultiEntryReferenceField: { DE: [mocks.entryLink], US: [mocks.entryLink] }, + mixedMultiEntryReferenceField: { + DE: [mocks.localizedEntry, mocks.entryLink], + US: [mocks.localizedEntry, mocks.entryLink], + }, + resolvableAssetReferenceField: { DE: mocks.localizedAsset, US: mocks.localizedAsset }, + unresolvableAssetReferenceField: { US: mocks.assetLink, DE: mocks.assetLink }, + resolvableMultiAssetReferenceField: { + DE: [mocks.localizedAsset], + US: [mocks.localizedAsset], + }, + unresolvableMultiAssetReferenceField: { DE: [mocks.assetLink], US: [mocks.assetLink] }, + mixedMultiAssetReferenceField: { + DE: [mocks.localizedAsset, mocks.assetLink], + US: [mocks.localizedAsset, mocks.assetLink], + }, }, - }), -) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.EntryLink - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: mocks.entryLink } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ - referenceField: EntryFieldTypes.Array> - }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [mocks.entryLink] } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: mocks.assetLink } })) - -expectNotAssignable< - Entry< - EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, - 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', - 'US' | 'DE' - > ->(mocks.getEntry({ referenceField: { US: [mocks.assetLink] } })) + }) + + /* links in single reference fields can be undefined because we can’t distinguish between missing translation and missing links */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + entryReferenceField: EntryFieldTypes.EntryLink + assetReferenceField: EntryFieldTypes.AssetLink + }>, + 'WITH_ALL_LOCALES', + 'US' | 'DE' + > + >( + mocks.getEntry({ + entryReferenceField: { US: undefined }, + assetReferenceField: { US: undefined }, + }), + ) + + expectTypeOf(mocks.getEntry({ referenceField: { US: [undefined] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.EntryLink[] + }>, + 'WITH_ALL_LOCALES', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: [undefined] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink[] }>, + 'WITH_ALL_LOCALES', + 'US' | 'DE' + > + >() + + /** + * EntryWithLinkResolutionAndWithoutUnresolvableLinks only resolvable entities are present. + * unresolvable links are completely removed. + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + resolvableEntryReferenceField: EntryFieldTypes.EntryLink + unresolvableEntryReferenceField: EntryFieldTypes.EntryLink + resolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + mixedMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + resolvableAssetReferenceField: EntryFieldTypes.AssetLink + unresolvableAssetReferenceField: EntryFieldTypes.AssetLink + resolvableMultiAssetReferenceField: EntryFieldTypes.Array + unresolvableMultiAssetReferenceField: EntryFieldTypes.Array + mixedMultiAssetReferenceField: EntryFieldTypes.Array + }>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >( + mocks.getEntry({ + stringField: mocks.stringValue, + resolvableEntryReferenceField: mocks.entry, + unresolvableEntryReferenceField: undefined, + resolvableMultiEntryReferenceField: [mocks.entry], + unresolvableMultiEntryReferenceField: [undefined], + mixedMultiEntryReferenceField: [mocks.entry, undefined], + resolvableAssetReferenceField: mocks.asset, + unresolvableAssetReferenceField: undefined, + resolvableMultiAssetReferenceField: [mocks.asset], + unresolvableMultiAssetReferenceField: [undefined], + mixedMultiAssetReferenceField: [mocks.asset, undefined], + }), + ) + + expectTypeOf(mocks.getEntry({ referenceField: mocks.entryLink })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.EntryLink + }>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: [mocks.entryLink] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.Array> + }>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: mocks.assetLink })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: [mocks.assetLink] })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + + /** + * EntryWithAllLocalesAndWithLinkResolutionAndWithoutUnresolvableLinks All unresolvable fields are removed + */ + expectTypeOf< + Entry< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Text + resolvableEntryReferenceField: EntryFieldTypes.EntryLink + unresolvableEntryReferenceField: EntryFieldTypes.EntryLink + resolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + unresolvableMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + mixedMultiEntryReferenceField: EntryFieldTypes.Array< + EntryFieldTypes.EntryLink + > + resolvableAssetReferenceField: EntryFieldTypes.AssetLink + unresolvableAssetReferenceField: EntryFieldTypes.AssetLink + resolvableMultiAssetReferenceField: EntryFieldTypes.Array + unresolvableMultiAssetReferenceField: EntryFieldTypes.Array + mixedMultiAssetReferenceField: EntryFieldTypes.Array + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', + 'US' | 'DE' + > + >( + mocks.getEntry({ + stringField: { US: mocks.stringValue, DE: mocks.stringValue }, + resolvableEntryReferenceField: { US: mocks.localizedEntry, DE: mocks.localizedEntry }, + unresolvableEntryReferenceField: { US: undefined, DE: undefined }, + resolvableMultiEntryReferenceField: { + US: [mocks.localizedEntry], + DE: [mocks.localizedEntry], + }, + unresolvableMultiEntryReferenceField: { US: [undefined], DE: [undefined] }, + mixedMultiEntryReferenceField: { + US: [mocks.localizedEntry, undefined], + DE: [mocks.localizedEntry, undefined], + }, + resolvableAssetReferenceField: { US: mocks.localizedAsset, DE: mocks.localizedAsset }, + unresolvableAssetReferenceField: { US: undefined, DE: undefined }, + resolvableMultiAssetReferenceField: { + US: [mocks.localizedAsset], + DE: [mocks.localizedAsset], + }, + unresolvableMultiAssetReferenceField: { US: [undefined], DE: [undefined] }, + mixedMultiAssetReferenceField: { + US: [mocks.localizedAsset, undefined], + DE: [mocks.localizedAsset, undefined], + }, + }), + ) + + expectTypeOf(mocks.getEntry({ referenceField: { US: mocks.entryLink } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.EntryLink + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: [mocks.entryLink] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ + referenceField: EntryFieldTypes.Array> + }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: mocks.assetLink } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.AssetLink }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', + 'US' | 'DE' + > + >() + + expectTypeOf(mocks.getEntry({ referenceField: { US: [mocks.assetLink] } })).not.toEqualTypeOf< + Entry< + EntrySkeletonType<{ referenceField: EntryFieldTypes.Array }>, + 'WITH_ALL_LOCALES' | 'WITHOUT_UNRESOLVABLE_LINKS', + 'US' | 'DE' + > + >() +}) \ No newline at end of file diff --git a/test/types/mocks.ts b/test/types/mocks.ts index af4c83280..0b5c9b690 100644 --- a/test/types/mocks.ts +++ b/test/types/mocks.ts @@ -155,4 +155,4 @@ export const localizedAssetFields = { export const asset = { ...assetBasics, fields: assetFields } -export const localizedAsset = { ...assetBasics, fields: localizedAssetFields } +export const localizedAsset = { ...assetBasics, fields: localizedAssetFields } \ No newline at end of file diff --git a/test/types/queries/asset-queries.test-d.ts b/test/types/queries/asset-queries.test-d.ts index d6e6f752f..efb4c74d3 100644 --- a/test/types/queries/asset-queries.test-d.ts +++ b/test/types/queries/asset-queries.test-d.ts @@ -1,19 +1,21 @@ -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { AssetFields, AssetsQueries } from '../../../lib' import * as mocks from '../mocks' type DefaultAssetQueries = AssetsQueries +test('assetQueries', async () => { + // all operator -expectAssignable({ +expectTypeOf({ 'metadata.tags.sys.id[all]': mocks.stringArrayValue, 'metadata.concepts.sys.id[all]': mocks.stringArrayValue, }) // equality operator -expectAssignable({ +expectTypeOf({ 'fields.description': mocks.stringValue, 'fields.file.contentType': mocks.stringValue, 'fields.file.details.size': mocks.numberValue, @@ -22,17 +24,17 @@ expectAssignable({ 'fields.title': mocks.stringValue, 'sys.updatedAt': mocks.dateValue, }) -expectNotAssignable({ +expectTypeOf({ 'fields.unknownField': mocks.anyValue, -}) +}).not.toEqualTypeOf() -expectNotAssignable({ +expectTypeOf({ 'sys.unknownProp': mocks.anyValue, -}) +}).not.toEqualTypeOf() // exists operator (field is present) -expectAssignable({ +expectTypeOf({ 'fields.description[exists]': mocks.booleanValue, 'fields.file[exists]': mocks.booleanValue, 'fields.file.contentType[exists]': mocks.booleanValue, @@ -45,41 +47,41 @@ expectAssignable({ 'metadata.concepts[exists]': mocks.booleanValue, 'sys.updatedAt[exists]': mocks.booleanValue, }) -expectAssignable({ +expectTypeOf({ 'metadata.tags.sys.id[all]': mocks.stringArrayValue, 'metadata.concepts.sys.id[all]': mocks.stringArrayValue, 'metadata.concepts.descendants[in]': mocks.stringArrayValue, }) -expectNotAssignable({ +expectTypeOf({ 'fields.unknownField[exists]': mocks.anyValue, -}) -expectNotAssignable({ +}).not.toEqualTypeOf() +expectTypeOf({ 'sys.unknownProp[exists]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // gt operator (range) -expectAssignable({ +expectTypeOf({ 'fields.file.details.size[gt]': mocks.numberValue, 'sys.updatedAt[gt]': mocks.dateValue, }) -expectNotAssignable({ +expectTypeOf({ 'sys.unknownProp[gt]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // gte operator (range) -expectAssignable({ +expectTypeOf({ 'fields.file.details.size[gte]': mocks.numberValue, 'sys.updatedAt[gte]': mocks.dateValue, }) -expectNotAssignable({ +expectTypeOf({ 'sys.unknownProp[gte]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // in operator -expectAssignable({ +expectTypeOf({ 'fields.description[in]': mocks.stringArrayValue, 'fields.file.contentType[in]': mocks.stringArrayValue, 'fields.file.details.size[in]': mocks.numberArrayValue, @@ -90,49 +92,49 @@ expectAssignable({ 'metadata.concepts.sys.id[in]': mocks.stringArrayValue, 'sys.updatedAt[in]': mocks.dateArrayValue, }) -expectNotAssignable({ +expectTypeOf({ 'fields.unknownField[in]': mocks.anyValue, -}) -expectNotAssignable({ +}).not.toEqualTypeOf() +expectTypeOf({ 'sys.unknownProp[in]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // lt operator (range) -expectAssignable({ +expectTypeOf({ 'fields.file.details.size[lt]': mocks.numberValue, 'sys.updatedAt[lt]': mocks.dateValue, }) -expectNotAssignable({ +expectTypeOf({ 'sys.unknownProp[lt]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // lte operator (range) -expectAssignable({ +expectTypeOf({ 'fields.file.details.size[lte]': mocks.numberValue, 'sys.updatedAt[lte]': mocks.dateValue, }) -expectNotAssignable({ +expectTypeOf({ 'sys.unknownProp[lte]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // match operator (full-text search) -expectAssignable({ +expectTypeOf({ 'fields.description[match]': mocks.stringValue, 'fields.file.contentType[match]': mocks.stringValue, 'fields.file.fileName[match]': mocks.stringValue, 'fields.file.url[match]': mocks.stringValue, 'fields.title[match]': mocks.stringValue, }) -expectNotAssignable({ +expectTypeOf({ 'fields.unknownField[match]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // ne operator (inequality) -expectAssignable({ +expectTypeOf({ 'fields.description[ne]': mocks.stringValue, 'fields.file.contentType[ne]': mocks.stringValue, 'fields.file.details.size[ne]': mocks.numberValue, @@ -141,16 +143,16 @@ expectAssignable({ 'fields.title[ne]': mocks.stringValue, 'sys.updatedAt[ne]': mocks.dateValue, }) -expectNotAssignable({ +expectTypeOf({ 'fields.unknownField[ne]': mocks.anyValue, -}) -expectNotAssignable({ +}).not.toEqualTypeOf() +expectTypeOf({ 'sys.unknownProp[ne]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // nin operator -expectAssignable({ +expectTypeOf({ 'fields.description[nin]': mocks.stringArrayValue, 'fields.file.contentType[nin]': mocks.stringArrayValue, 'fields.file.details.size[nin]': mocks.numberArrayValue, @@ -161,19 +163,19 @@ expectAssignable({ 'metadata.concepts.sys.id[nin]': mocks.stringArrayValue, 'sys.updatedAt[nin]': mocks.dateArrayValue, }) -expectNotAssignable({ +expectTypeOf({ 'fields.unknownField[nin]': mocks.anyValue, -}) -expectNotAssignable({ +}).not.toEqualTypeOf() +expectTypeOf({ 'sys.unknownProp[nin]': mocks.anyValue, -}) +}).not.toEqualTypeOf() // order operator -expectAssignable({ order: ['sys.createdAt', '-sys.createdAt'] }) -expectNotAssignable({ order: ['sys.unknownProperty'] }) +expectTypeOf({ order: ['sys.createdAt', '-sys.createdAt'] }) +expectTypeOf({ order: ['sys.unknownProperty'] }).not.toEqualTypeOf() -expectAssignable({ +expectTypeOf({ order: [ 'fields.file.contentType', '-fields.file.contentType', @@ -185,19 +187,19 @@ expectAssignable({ '-fields.file.details.size', ], }) -expectNotAssignable({ order: ['fields.unknownField'] }) +expectTypeOf({ order: ['fields.unknownField'] }).not.toEqualTypeOf() // select operator -expectAssignable({ select: ['sys'] }) -expectAssignable({ select: ['sys.createdAt'] }) -expectNotAssignable({ select: ['sys.unknownProperty'] }) +expectTypeOf({ select: ['sys'] }) +expectTypeOf({ select: ['sys.createdAt'] }) +expectTypeOf({ select: ['sys.unknownProperty'] }).not.toEqualTypeOf() -expectAssignable({ select: ['fields'] }) -expectAssignable({ select: ['fields.title'] }) -expectNotAssignable({ select: ['fields.unknownField'] }) +expectTypeOf({ select: ['fields'] }) +expectTypeOf({ select: ['fields.title'] }) +expectTypeOf({ select: ['fields.unknownField'] }).not.toEqualTypeOf() // locale option -expectAssignable>({ locale: mocks.stringValue }) -expectNotAssignable>({ locale: mocks.anyValue }) +expectTypeOf>({ locale: mocks.stringValue }) +expectTypeOf({ locale: mocks.anyValue }).not.toEqualTypeOf>()}) \ No newline at end of file diff --git a/test/types/queries/entry-queries.test-d.ts b/test/types/queries/entry-queries.test-d.ts index cc3173ab8..ece06857c 100644 --- a/test/types/queries/entry-queries.test-d.ts +++ b/test/types/queries/entry-queries.test-d.ts @@ -1,483 +1,363 @@ -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntriesQueries, EntrySkeletonType, EntryFieldTypes } from '../../../lib' import * as mocks from '../mocks' +test('entryQueries', async () => { + // all operator -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Symbol - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf + }>, + undefined +>>({ 'metadata.tags.sys.id[all]': mocks.stringArrayValue, 'metadata.concepts.sys.id[all]': mocks.stringArrayValue, }) -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Symbol - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf + }>, + undefined +>>({ 'metadata.tags.sys.id[all]': mocks.stringArrayValue, 'metadata.concepts.sys.id[all]': mocks.stringArrayValue, 'metadata.concepts.descendants[in]': mocks.stringArrayValue, }) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Symbol - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf({ 'fields.stringField[all]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Symbol - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +}).not.toEqualTypeOf + }>, + undefined +>>() +expectTypeOf + }>, + undefined +>>({ content_type: 'id', 'fields.stringField[all]': mocks.stringArrayValue, 'fields.stringArrayField[all]': mocks.stringArrayValue, }) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Symbol - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf({ content_type: 'id', 'fields.unknownField[all]': mocks.anyValue, -}) +}).not.toEqualTypeOf + }>, + undefined +>>() // equality -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'sys.updatedAt': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.someField': mocks.stringValue, 'sys.updatedAt': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // exists operator (field is present) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'metadata.tags[exists]': mocks.booleanValue, 'metadata.concepts[exists]': mocks.booleanValue, 'sys.updatedAt[exists]': mocks.booleanValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField[exists]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.someField[exists]': mocks.booleanValue, 'sys.updatedAt[exists]': mocks.booleanValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[exists]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[exists]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // gt operator (range) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'sys.updatedAt[gt]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField[gt]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.numberField[gt]': mocks.numberValue, 'sys.updatedAt[gt]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[gt]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[gt]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // gte operator (range) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'sys.updatedAt[gte]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField[gte]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.numberField[gte]': mocks.numberValue, 'sys.updatedAt[gte]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[gte]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[gte]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // in operator -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf + }>, + undefined +>>({ 'metadata.tags.sys.id[in]': mocks.stringArrayValue, 'metadata.concepts.sys.id[in]': mocks.stringArrayValue, 'sys.updatedAt[in]': mocks.dateArrayValue, }) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf({ 'fields.numberField[in]': mocks.anyValue, 'fields.stringArrayField[in]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +}).not.toEqualTypeOf + }>, + undefined +>>() +expectTypeOf + }>, + undefined +>>({ content_type: 'id', 'fields.numberField[in]': mocks.numberArrayValue, 'fields.stringArrayField[in]': mocks.stringArrayValue, 'sys.updatedAt[in]': mocks.dateArrayValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[in]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[in]': mocks.anyValue, -}) +}).not.toEqualTypeOf + }>, + undefined +>>() // lt operator (range) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'sys.updatedAt[lt]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField[lt]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.numberField[lt]': mocks.numberValue, 'sys.updatedAt[lt]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[lt]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[lt]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // lte operator (range) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'sys.updatedAt[lte]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField[lte]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.numberField[lte]': mocks.numberValue, 'sys.updatedAt[lte]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[lte]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[lte]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // match operator (full-text search) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.textField[match]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.textField[match]': mocks.stringValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ content_type: 'id', 'fields.unknownField[match]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // ne operator (inequality) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ 'sys.updatedAt[ne]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.numberField[ne]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.someField[ne]': mocks.stringValue, 'sys.updatedAt[ne]': mocks.dateValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[ne]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[ne]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // near operator (full-text search) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.locationField[near]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.locationField[near]': mocks.nearLocationValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ content_type: 'id', 'fields.unknownField[near]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // nin operator -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf + }>, + undefined +>>({ 'metadata.tags.sys.id[nin]': mocks.stringArrayValue, 'metadata.concepts.sys.id[nin]': mocks.stringArrayValue, 'sys.updatedAt[nin]': mocks.dateArrayValue, }) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +expectTypeOf({ 'fields.numberField[nin]': mocks.anyValue, 'fields.stringArrayField[nin]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +}).not.toEqualTypeOf + }>, + undefined +>>() +expectTypeOf + }>, + undefined +>>({ content_type: 'id', 'fields.numberField[nin]': mocks.numberArrayValue, 'fields.stringArrayField[nin]': mocks.stringArrayValue, 'sys.updatedAt[nin]': mocks.dateArrayValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'sys.unknownProp[nin]': mocks.anyValue, -}) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ - numberField: EntryFieldTypes.Number - stringArrayField: EntryFieldTypes.Array - }>, - undefined - > ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf({ content_type: 'id', 'fields.unknownField[nin]': mocks.anyValue, -}) +}).not.toEqualTypeOf + }>, + undefined +>>() // order operator -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ order: ['sys.createdAt', '-sys.createdAt'], }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ order: ['sys.unknownProperty'], -}) +}).not.toEqualTypeOf, undefined>>() -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ order: ['fields.someField'], -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', order: ['fields.someField', '-fields.someField'], }) -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - mediaField: EntryFieldTypes.AssetLink - referenceField: EntryFieldTypes.EntryLink - }>, - undefined - > ->({ +expectTypeOf + }>, + undefined +>>({ content_type: 'id', order: [ 'fields.mediaField.sys.id', @@ -486,122 +366,84 @@ expectAssignable< '-fields.referenceField.sys.id', ], }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ content_type: 'id', order: ['fields.unknownField'], -}) +}).not.toEqualTypeOf, undefined>>() // select operator -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ select: ['sys'], }) -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ select: ['sys.createdAt'], }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ select: ['sys.unknownProperty'], -}) +}).not.toEqualTypeOf, undefined>>() -expectAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf, undefined>>({ select: ['fields'], }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ select: ['fields.someField'], -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', select: ['fields.someField'], }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ content_type: 'id', select: ['fields.unknownField'], -}) +}).not.toEqualTypeOf, undefined>>() // within operator (bounding circle) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.locationField[within]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.locationField[within]': mocks.withinCircleLocationValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ content_type: 'id', 'fields.unknownField[within]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // within operator (bounding rectangle) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ 'fields.locationField[within]': mocks.anyValue, -}) -expectAssignable< - EntriesQueries, undefined> ->({ +}).not.toEqualTypeOf, undefined>>() +expectTypeOf, undefined>>({ content_type: 'id', 'fields.locationField[within]': mocks.withinBoxLocationValue, }) -expectNotAssignable< - EntriesQueries, undefined> ->({ +expectTypeOf({ content_type: 'id', 'fields.unknownField[within]': mocks.anyValue, -}) +}).not.toEqualTypeOf, undefined>>() // search on references -expectNotAssignable< - EntriesQueries }>, undefined> ->({ +expectTypeOf({ 'fields.referenceField.sys.contentType.sys.id': 'id', -}) -expectAssignable< - EntriesQueries }>, undefined> ->({ +}).not.toEqualTypeOf }>, undefined>>() +expectTypeOf }>, undefined>>({ content_type: 'id', 'fields.referenceField.sys.contentType.sys.id': 'id', }) -expectNotAssignable< - EntriesQueries }>, undefined> ->({ +expectTypeOf({ content_type: 'id', 'fields.unknownField.sys.contentType.sys.id': 'id', -}) +}).not.toEqualTypeOf }>, undefined>>() // locale option -expectAssignable< - EntriesQueries }>, undefined> ->({ locale: mocks.stringValue }) -expectNotAssignable< - EntriesQueries< - EntrySkeletonType<{ referenceField: EntryFieldTypes.EntryLink }>, - 'WITH_ALL_LOCALES' - > ->({ locale: mocks.anyValue }) +expectTypeOf }>, undefined>>({ locale: mocks.stringValue }) +expectTypeOf({ locale: mocks.anyValue }).not.toEqualTypeOf }>, + 'WITH_ALL_LOCALES' +>>()}) \ No newline at end of file diff --git a/test/types/queries/tag-queries.test-d.ts b/test/types/queries/tag-queries.test-d.ts index f3d7cf971..3568b9bfc 100644 --- a/test/types/queries/tag-queries.test-d.ts +++ b/test/types/queries/tag-queries.test-d.ts @@ -1,129 +1,131 @@ -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { TagQueries } from '../../../lib' import * as mocks from '../mocks' +test('tagQueries', async () => { + // equality operator -expectAssignable({ +expectTypeOf({ 'sys.id': mocks.stringValue, 'sys.createdAt': mocks.dateValue, 'sys.updatedAt': mocks.dateValue, 'sys.visibility': mocks.stringValue, 'sys.type': mocks.stringValue, }) -expectNotAssignable({ 'sys.createdBy': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy': mocks.anyValue }) -expectNotAssignable({ 'sys.version': mocks.anyValue }) -expectNotAssignable({ 'sys.revision': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision': mocks.anyValue }).not.toEqualTypeOf() // gt operator (range) -expectAssignable({ +expectTypeOf({ 'sys.createdAt[gt]': mocks.dateValue, 'sys.updatedAt[gt]': mocks.dateValue, }) -expectNotAssignable({ 'sys.createdBy[gt]': mocks.anyValue }) -expectNotAssignable({ 'sys.id[gt]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[gt]': mocks.anyValue }) -expectNotAssignable({ 'sys.type[gt]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[gt]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[gt]': mocks.anyValue }) -expectNotAssignable({ 'sys.visibility[gt]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[gt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.id[gt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[gt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.type[gt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[gt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[gt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.visibility[gt]': mocks.anyValue }).not.toEqualTypeOf() // gte operator (range) -expectAssignable({ +expectTypeOf({ 'sys.createdAt[gte]': mocks.dateValue, 'sys.updatedAt[gte]': mocks.dateValue, }) -expectNotAssignable({ 'sys.createdBy[gte]': mocks.anyValue }) -expectNotAssignable({ 'sys.id[gte]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[gte]': mocks.anyValue }) -expectNotAssignable({ 'sys.type[gte]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[gte]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[gte]': mocks.anyValue }) -expectNotAssignable({ 'sys.visibility[gte]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[gte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.id[gte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[gte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.type[gte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[gte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[gte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.visibility[gte]': mocks.anyValue }).not.toEqualTypeOf() // in operator -expectAssignable({ +expectTypeOf({ 'sys.id[in]': mocks.stringArrayValue, 'sys.createdAt[in]': mocks.dateArrayValue, 'sys.updatedAt[in]': mocks.dateArrayValue, 'sys.visibility[in]': mocks.stringArrayValue, 'sys.type[in]': mocks.stringArrayValue, }) -expectNotAssignable({ 'sys.createdBy[in]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[in]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[in]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[in]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[in]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[in]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[in]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[in]': mocks.anyValue }).not.toEqualTypeOf() // lt operator (range) -expectAssignable({ +expectTypeOf({ 'sys.createdAt[lt]': mocks.dateValue, 'sys.updatedAt[lt]': mocks.dateValue, }) -expectNotAssignable({ 'sys.createdBy[lt]': mocks.anyValue }) -expectNotAssignable({ 'sys.id[lt]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[lt]': mocks.anyValue }) -expectNotAssignable({ 'sys.type[lt]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[lt]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[lt]': mocks.anyValue }) -expectNotAssignable({ 'sys.visibility[lt]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[lt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.id[lt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[lt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.type[lt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[lt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[lt]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.visibility[lt]': mocks.anyValue }).not.toEqualTypeOf() // lte operator (range) -expectAssignable({ +expectTypeOf({ 'sys.createdAt[lte]': mocks.dateValue, 'sys.updatedAt[lte]': mocks.dateValue, }) -expectNotAssignable({ 'sys.createdBy[lte]': mocks.anyValue }) -expectNotAssignable({ 'sys.id[lte]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[lte]': mocks.anyValue }) -expectNotAssignable({ 'sys.type[lte]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[lte]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[lte]': mocks.anyValue }) -expectNotAssignable({ 'sys.visibility[lte]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[lte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.id[lte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[lte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.type[lte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[lte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[lte]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.visibility[lte]': mocks.anyValue }).not.toEqualTypeOf() // ne operator (inequality) -expectAssignable({ +expectTypeOf({ 'sys.id[ne]': mocks.stringValue, 'sys.createdAt[ne]': mocks.dateValue, 'sys.updatedAt[ne]': mocks.dateValue, 'sys.visibility[ne]': mocks.stringValue, 'sys.type[ne]': mocks.stringValue, }) -expectNotAssignable({ 'sys.createdBy[ne]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[ne]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[ne]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[ne]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[ne]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[ne]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[ne]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[ne]': mocks.anyValue }).not.toEqualTypeOf() // nin operator -expectAssignable({ +expectTypeOf({ 'sys.id[nin]': mocks.stringArrayValue, 'sys.createdAt[nin]': mocks.dateArrayValue, 'sys.updatedAt[nin]': mocks.dateArrayValue, 'sys.visibility[nin]': mocks.stringArrayValue, 'sys.type[nin]': mocks.stringArrayValue, }) -expectNotAssignable({ 'sys.createdBy[nin]': mocks.anyValue }) -expectNotAssignable({ 'sys.updatedBy[nin]': mocks.anyValue }) -expectNotAssignable({ 'sys.version[nin]': mocks.anyValue }) -expectNotAssignable({ 'sys.revision[nin]': mocks.anyValue }) +expectTypeOf({ 'sys.createdBy[nin]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.updatedBy[nin]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.version[nin]': mocks.anyValue }).not.toEqualTypeOf() +expectTypeOf({ 'sys.revision[nin]': mocks.anyValue }).not.toEqualTypeOf() // order operator -expectAssignable({ +expectTypeOf({ order: ['sys.id', 'sys.createdAt', 'sys.updatedAt', 'sys.visibility', 'sys.type'], }) -expectAssignable({ +expectTypeOf({ order: ['-sys.id', '-sys.createdAt', '-sys.updatedAt', '-sys.visibility', '-sys.type'], }) // Fixed query filters -expectAssignable({ skip: 1, limit: 1 }) -expectNotAssignable({ locale: 'en' }) +expectTypeOf({ skip: 1, limit: 1 }) +expectTypeOf({ locale: 'en' }).not.toEqualTypeOf()}) \ No newline at end of file diff --git a/test/types/query-types/boolean.test-d.ts b/test/types/query-types/boolean.test-d.ts index bae38b071..b7af8a50e 100644 --- a/test/types/query-types/boolean.test-d.ts +++ b/test/types/query-types/boolean.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from 'vitest' import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,53 +16,57 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>( - {}, -) +test('boolean', async () => { + expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ - 'fields.testField': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField': mocks.booleanValue, + }) -expectAssignable>({}) -expectType< - Required> ->({ - 'fields.testField[ne]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[ne]': mocks.booleanValue, + }) -expectAssignable>({}) -expectType>>( - { + expectTypeOf>({}) + expectTypeOf< + Required> + >({ 'fields.testField[exists]': mocks.booleanValue, - }, -) + }) -expectAssignable>>( - {}, -) + expectTypeOf>>( + {}, + ) -expectAssignable< - Required> ->({}) + expectTypeOf>>( + {}, + ) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectAssignable>>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + order: ['fields.testField', '-fields.testField'], + }) -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[in]': mocks.booleanArrayValue, - 'fields.testField[nin]': mocks.booleanArrayValue, + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[in]': mocks.booleanArrayValue, + 'fields.testField[nin]': mocks.booleanArrayValue, + }) }) diff --git a/test/types/query-types/date.test-d.ts b/test/types/query-types/date.test-d.ts index cd9cfc796..823b46c9a 100644 --- a/test/types/query-types/date.test-d.ts +++ b/test/types/query-types/date.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from 'vitest' import { EntryFieldsEqualityFilter, EntryFieldsInequalityFilter, @@ -16,49 +16,57 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>({}) +test('date', async () => { + expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ - 'fields.testField': mocks.dateValue, -}) + expectTypeOf>({}) + expectTypeOf>>( + { + 'fields.testField': mocks.dateValue, + }, + ) -expectAssignable>({}) -expectType>>({ - 'fields.testField[ne]': mocks.dateValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[ne]': mocks.dateValue, + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[exists]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectAssignable>>({}) + expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ - 'fields.testField[lt]': mocks.dateValue, - 'fields.testField[lte]': mocks.dateValue, - 'fields.testField[gt]': mocks.dateValue, - 'fields.testField[gte]': mocks.dateValue, -}) + expectTypeOf>({}) + expectTypeOf>>({ + 'fields.testField[lt]': mocks.dateValue, + 'fields.testField[lte]': mocks.dateValue, + 'fields.testField[gt]': mocks.dateValue, + 'fields.testField[gte]': mocks.dateValue, + }) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectAssignable>>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + order: ['fields.testField', '-fields.testField'], + }) -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[in]': mocks.dateArrayValue, - 'fields.testField[nin]': mocks.dateArrayValue, + expectTypeOf>({}) + expectTypeOf>>({ + 'fields.testField[in]': mocks.dateArrayValue, + 'fields.testField[nin]': mocks.dateArrayValue, + }) }) diff --git a/test/types/query-types/integer.test-d.ts b/test/types/query-types/integer.test-d.ts index e92181256..5af57bcc7 100644 --- a/test/types/query-types/integer.test-d.ts +++ b/test/types/query-types/integer.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldsEqualityFilter, EntryFieldsInequalityFilter, @@ -16,57 +16,63 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>( - {}, -) +test('integer', async () => { + expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ - 'fields.testField': mocks.numberValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField': mocks.numberValue, + }) -expectAssignable>({}) -expectType< - Required> ->({ - 'fields.testField[ne]': mocks.numberValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[ne]': mocks.numberValue, + }) -expectAssignable>({}) -expectType>>( - { + expectTypeOf>({}) + expectTypeOf< + Required> + >({ 'fields.testField[exists]': mocks.booleanValue, - }, -) + }) -expectAssignable>>( - {}, -) + expectTypeOf>>( + {}, + ) -expectAssignable>({}) -expectType>>({ - 'fields.testField[lt]': mocks.numberValue, - 'fields.testField[lte]': mocks.numberValue, - 'fields.testField[gt]': mocks.numberValue, - 'fields.testField[gte]': mocks.numberValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[lt]': mocks.numberValue, + 'fields.testField[lte]': mocks.numberValue, + 'fields.testField[gt]': mocks.numberValue, + 'fields.testField[gte]': mocks.numberValue, + }) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectAssignable>>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + order: ['fields.testField', '-fields.testField'], + }) -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[in]': mocks.numberArrayValue, - 'fields.testField[nin]': mocks.numberArrayValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[in]': mocks.numberArrayValue, + 'fields.testField[nin]': mocks.numberArrayValue, + }) +}) \ No newline at end of file diff --git a/test/types/query-types/location.test-d.ts b/test/types/query-types/location.test-d.ts index 120726c09..c94a1df85 100644 --- a/test/types/query-types/location.test-d.ts +++ b/test/types/query-types/location.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectNotAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,69 +16,75 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>( - {}, -) +test('location', async () => { + expectTypeOf>>( + {}, + ) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectType< - Required> ->({ - 'fields.testField[exists]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectAssignable>({}) -expectAssignable< - Required> ->({ - 'fields.testField[near]': mocks.nearLocationValue, - 'fields.testField[within]': mocks.withinCircleLocationValue, -}) -expectAssignable< - Required> ->({ - 'fields.testField[near]': mocks.nearLocationValue, - 'fields.testField[within]': mocks.withinBoxLocationValue, -}) -expectNotAssignable< - LocationSearchFilters<{ testField: EntryFieldTypes.Location }, 'fields'>['fields.testField[near]'] ->(mocks.withinCircleLocationValue) -expectNotAssignable< - LocationSearchFilters<{ testField: EntryFieldTypes.Location }, 'fields'>['fields.testField[near]'] ->(mocks.withinBoxLocationValue) -expectNotAssignable< - LocationSearchFilters< - { testField: EntryFieldTypes.Location }, - 'fields' - >['fields.testField[within]'] ->(mocks.nearLocationValue) + expectTypeOf>({}) + expectTypeOf>>( + { + 'fields.testField[near]': mocks.nearLocationValue, + 'fields.testField[within]': mocks.withinCircleLocationValue, + }, + ) + expectTypeOf>>({ + 'fields.testField[near]': mocks.nearLocationValue, + 'fields.testField[within]': mocks.withinBoxLocationValue, + }) + expectTypeOf(mocks.withinCircleLocationValue).not.toEqualTypeOf< + LocationSearchFilters< + { testField: EntryFieldTypes.Location }, + 'fields' + >['fields.testField[near]'] + >() + expectTypeOf(mocks.withinBoxLocationValue).not.toEqualTypeOf< + LocationSearchFilters< + { testField: EntryFieldTypes.Location }, + 'fields' + >['fields.testField[near]'] + >() + expectTypeOf(mocks.nearLocationValue).not.toEqualTypeOf< + LocationSearchFilters< + { testField: EntryFieldTypes.Location }, + 'fields' + >['fields.testField[within]'] + >() -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectAssignable>>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + order: ['fields.testField', '-fields.testField'], + }) -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) +}) \ No newline at end of file diff --git a/test/types/query-types/number.test-d.ts b/test/types/query-types/number.test-d.ts index e72a93fdc..f5322ffb2 100644 --- a/test/types/query-types/number.test-d.ts +++ b/test/types/query-types/number.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,53 +16,61 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>( - {}, -) +test('number', async () => { + expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ - 'fields.testField': mocks.numberValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField': mocks.numberValue, + }) -expectAssignable>({}) -expectType>>( - { + expectTypeOf>({}) + expectTypeOf< + Required> + >({ 'fields.testField[ne]': mocks.numberValue, - }, -) + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[exists]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectType>>({}) + expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ - 'fields.testField[lt]': mocks.numberValue, - 'fields.testField[lte]': mocks.numberValue, - 'fields.testField[gt]': mocks.numberValue, - 'fields.testField[gte]': mocks.numberValue, -}) + expectTypeOf>({}) + expectTypeOf>>( + { + 'fields.testField[lt]': mocks.numberValue, + 'fields.testField[lte]': mocks.numberValue, + 'fields.testField[gt]': mocks.numberValue, + 'fields.testField[gte]': mocks.numberValue, + }, + ) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectAssignable>>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + order: ['fields.testField', '-fields.testField'], + }) -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[in]': mocks.numberArrayValue, - 'fields.testField[nin]': mocks.numberArrayValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[in]': mocks.numberArrayValue, + 'fields.testField[nin]': mocks.numberArrayValue, + }) +}) \ No newline at end of file diff --git a/test/types/query-types/object.test-d.ts b/test/types/query-types/object.test-d.ts index 57ba27d03..96368ea7a 100644 --- a/test/types/query-types/object.test-d.ts +++ b/test/types/query-types/object.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectNotAssignable, expectType } from 'tsd' +import { test, expectTypeOf } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,44 +16,33 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>( - {}, -) +test('object', () => { -expectAssignable< - Required> ->({}) +expectTypeOf>>({}) -expectAssignable< - Required> ->({}) +expectTypeOf>>({}) -expectAssignable>({}) -expectType>>({ +expectTypeOf>>({}) + +expectTypeOf>({}) +expectTypeOf>>({ 'fields.testField[exists]': mocks.booleanValue, }) -expectAssignable>>( - {}, -) +expectTypeOf>>({}) -expectAssignable< - Required> ->({}) +expectTypeOf>>({}) -expectAssignable< - Required> ->({}) +expectTypeOf>>({}) -expectNotAssignable>({ +expectTypeOf({ order: ['fields.testField'], -}) +}).not.toEqualTypeOf>() -expectAssignable>({}) -expectAssignable>>({ +expectTypeOf>({}) +expectTypeOf>>({ select: ['fields.testField'], }) -expectAssignable< - Required> ->({}) +expectTypeOf>>({}) +}) \ No newline at end of file diff --git a/test/types/query-types/richtext.test-d.ts b/test/types/query-types/richtext.test-d.ts index 756b6790b..3a48e70e4 100644 --- a/test/types/query-types/richtext.test-d.ts +++ b/test/types/query-types/richtext.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectNotAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,49 +16,53 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>>( - {}, -) +test('richtext', async () => { + expectTypeOf>>( + {}, + ) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) -expectAssignable>({}) -expectType< - Required> ->({ - 'fields.testField[exists]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectAssignable< - Required> ->({}) + expectTypeOf>>( + {}, + ) -expectType>>({}) + expectTypeOf< + Required> + >({}) -expectAssignable< - EntryFieldsFullTextSearchFilters<{ testField: EntryFieldTypes.RichText }, 'fields'> ->({}) -expectType< - Required> ->({ - 'fields.testField[match]': mocks.stringValue, -}) + expectTypeOf>( + {}, + ) + expectTypeOf< + Required> + >({ + 'fields.testField[match]': mocks.stringValue, + }) -expectNotAssignable>({ - order: ['fields.testField'], -}) + expectTypeOf({ + order: ['fields.testField'], + }).not.toEqualTypeOf>() -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable< - Required> ->({}) + expectTypeOf< + Required> + >({}) +}) \ No newline at end of file diff --git a/test/types/query-types/symbol-array.test-d.ts b/test/types/query-types/symbol-array.test-d.ts index 894a6bffe..230d0e90c 100644 --- a/test/types/query-types/symbol-array.test-d.ts +++ b/test/types/query-types/symbol-array.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectNotAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,119 +16,132 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable< - EntryFieldsSetFilter<{ testField: EntryFieldTypes.Array }, 'fields'> ->({}) -expectType< - Required< - EntryFieldsSetFilter<{ testField?: EntryFieldTypes.Array }, 'fields'> - > ->({ - 'fields.testField[all]': mocks.stringArrayValue, -}) +test('symbol-array', async () => { + expectTypeOf< + EntryFieldsSetFilter<{ testField: EntryFieldTypes.Array }, 'fields'> + >({}) + expectTypeOf< + Required< + EntryFieldsSetFilter<{ testField?: EntryFieldTypes.Array }, 'fields'> + > + >({ + 'fields.testField[all]': mocks.stringArrayValue, + }) -expectAssignable< - EntryFieldsEqualityFilter<{ testField: EntryFieldTypes.Array }, 'fields'> ->({}) -expectType< - Required< + expectTypeOf< EntryFieldsEqualityFilter< - { testField?: EntryFieldTypes.Array }, + { testField: EntryFieldTypes.Array }, 'fields' > - > ->({ - 'fields.testField': mocks.stringValue, -}) + >({}) + expectTypeOf< + Required< + EntryFieldsEqualityFilter< + { testField?: EntryFieldTypes.Array }, + 'fields' + > + > + >({ + 'fields.testField': mocks.stringValue, + }) -expectAssignable< - EntryFieldsInequalityFilter< - { testField: EntryFieldTypes.Array }, - 'fields' - > ->({}) -expectType< - Required< + expectTypeOf< EntryFieldsInequalityFilter< - { testField?: EntryFieldTypes.Array }, + { testField: EntryFieldTypes.Array }, 'fields' > - > ->({ - 'fields.testField[ne]': mocks.stringValue, -}) + >({}) + expectTypeOf< + Required< + EntryFieldsInequalityFilter< + { testField?: EntryFieldTypes.Array }, + 'fields' + > + > + >({ + 'fields.testField[ne]': mocks.stringValue, + }) -expectAssignable< - EntryFieldsExistenceFilter<{ testField: EntryFieldTypes.Array }, 'fields'> ->({}) -expectType< - Required< + expectTypeOf< EntryFieldsExistenceFilter< - { testField?: EntryFieldTypes.Array }, + { testField: EntryFieldTypes.Array }, 'fields' > - > ->({ - 'fields.testField[exists]': mocks.booleanValue, -}) + >({}) + expectTypeOf< + Required< + EntryFieldsExistenceFilter< + { testField?: EntryFieldTypes.Array }, + 'fields' + > + > + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectAssignable< - Required< - LocationSearchFilters<{ testField: EntryFieldTypes.Array }, 'fields'> - > ->({}) + expectTypeOf< + Required< + LocationSearchFilters<{ testField: EntryFieldTypes.Array }, 'fields'> + > + >({}) -expectAssignable< - Required< - EntryFieldsRangeFilters<{ testField: EntryFieldTypes.Array }, 'fields'> - > ->({}) + expectTypeOf< + Required< + EntryFieldsRangeFilters< + { testField: EntryFieldTypes.Array }, + 'fields' + > + > + >({}) -expectAssignable< - EntryFieldsFullTextSearchFilters< - { testField: EntryFieldTypes.Array }, - 'fields' - > ->({}) -expectType< - Required< + expectTypeOf< EntryFieldsFullTextSearchFilters< - { testField?: EntryFieldTypes.Array }, + { testField: EntryFieldTypes.Array }, 'fields' > - > ->({ - 'fields.testField[match]': mocks.stringValue, -}) + >({}) + expectTypeOf< + Required< + EntryFieldsFullTextSearchFilters< + { testField?: EntryFieldTypes.Array }, + 'fields' + > + > + >({ + 'fields.testField[match]': mocks.stringValue, + }) -expectNotAssignable< - Required }>> ->({ - order: ['fields.testField'], -}) + expectTypeOf({ + order: ['fields.testField'], + }).not.toEqualTypeOf< + Required< + EntryOrderFilterWithFields<{ testField: EntryFieldTypes.Array }> + > + >() -expectAssignable< - EntrySelectFilterWithFields<{ testField: EntryFieldTypes.Array }> ->({}) -expectAssignable< - Required< + expectTypeOf< EntrySelectFilterWithFields<{ testField: EntryFieldTypes.Array }> - > ->({ - select: ['fields.testField'], -}) + >({}) + expectTypeOf< + Required< + EntrySelectFilterWithFields<{ testField: EntryFieldTypes.Array }> + > + >({ + select: ['fields.testField'], + }) -expectAssignable< - EntryFieldsSubsetFilters<{ testField: EntryFieldTypes.Array }, 'fields'> ->({}) -expectType< - Required< - EntryFieldsSubsetFilters< - { testField?: EntryFieldTypes.Array }, - 'fields' + expectTypeOf< + EntryFieldsSubsetFilters<{ testField: EntryFieldTypes.Array }, 'fields'> + >({}) + expectTypeOf< + Required< + EntryFieldsSubsetFilters< + { testField?: EntryFieldTypes.Array }, + 'fields' + > > - > ->({ - 'fields.testField[in]': mocks.stringArrayValue, - 'fields.testField[nin]': mocks.stringArrayValue, -}) + >({ + 'fields.testField[in]': mocks.stringArrayValue, + 'fields.testField[nin]': mocks.stringArrayValue, + }) +}) \ No newline at end of file diff --git a/test/types/query-types/symbol.test-d.ts b/test/types/query-types/symbol.test-d.ts index 213ef7be1..f38e1efbf 100644 --- a/test/types/query-types/symbol.test-d.ts +++ b/test/types/query-types/symbol.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,57 +16,63 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>({}) -expectType>>({ - 'fields.testField[all]': mocks.stringArrayValue, -}) +test('symbol', async () => { + expectTypeOf>({}) + expectTypeOf>>({ + 'fields.testField[all]': mocks.stringArrayValue, + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField': mocks.stringValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField': mocks.stringValue, + }) -expectAssignable>({}) -expectType>>( - { + expectTypeOf>({}) + expectTypeOf< + Required> + >({ 'fields.testField[ne]': mocks.stringValue, - }, -) + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[exists]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectAssignable>>( - {}, -) + expectTypeOf>>({}) -expectAssignable< - Required> ->({}) + expectTypeOf>>( + {}, + ) -expectAssignable>( - {}, -) -expectType< - Required> ->({ - 'fields.testField[match]': mocks.stringValue, -}) + expectTypeOf>( + {}, + ) + expectTypeOf< + Required> + >({ + 'fields.testField[match]': mocks.stringValue, + }) -expectAssignable>({}) -expectAssignable>>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + order: ['fields.testField', '-fields.testField'], + }) -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[in]': mocks.stringArrayValue, - 'fields.testField[nin]': mocks.stringArrayValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[in]': mocks.stringArrayValue, + 'fields.testField[nin]': mocks.stringArrayValue, + }) +}) \ No newline at end of file diff --git a/test/types/query-types/tagName.test-d.ts b/test/types/query-types/tagName.test-d.ts index 61287df98..322d38b35 100644 --- a/test/types/query-types/tagName.test-d.ts +++ b/test/types/query-types/tagName.test-d.ts @@ -1,22 +1,24 @@ -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { TagNameFilters } from '../../../lib' // @ts-ignore import * as mocks from '../mocks' -expectAssignable({ - 'name[exists]': mocks.booleanValue, - name: mocks.stringValue, - 'name[match]': mocks.stringValue, - 'name[ne]': mocks.stringValue, - 'name[in]': mocks.stringArrayValue, - 'name[nin]': mocks.stringArrayValue, -}) +test('tagName', async () => { + expectTypeOf({ + 'name[exists]': mocks.booleanValue, + name: mocks.stringValue, + 'name[match]': mocks.stringValue, + 'name[ne]': mocks.stringValue, + 'name[in]': mocks.stringArrayValue, + 'name[nin]': mocks.stringArrayValue, + }) -expectNotAssignable({ 'name[near]': mocks.anyValue }) -expectNotAssignable({ 'name[within]': mocks.anyValue }) -expectNotAssignable({ select: mocks.anyValue }) -expectNotAssignable({ 'name[lt]': mocks.anyValue }) -expectNotAssignable({ 'name[lte]': mocks.anyValue }) -expectNotAssignable({ 'name[gt]': mocks.anyValue }) -expectNotAssignable({ 'name[gte]': mocks.anyValue }) + expectTypeOf({ 'name[near]': mocks.anyValue }).not.toEqualTypeOf() + expectTypeOf({ 'name[within]': mocks.anyValue }).not.toEqualTypeOf() + expectTypeOf({ select: mocks.anyValue }).not.toEqualTypeOf() + expectTypeOf({ 'name[lt]': mocks.anyValue }).not.toEqualTypeOf() + expectTypeOf({ 'name[lte]': mocks.anyValue }).not.toEqualTypeOf() + expectTypeOf({ 'name[gt]': mocks.anyValue }).not.toEqualTypeOf() + expectTypeOf({ 'name[gte]': mocks.anyValue }).not.toEqualTypeOf() +}) \ No newline at end of file diff --git a/test/types/query-types/text.test-d.ts b/test/types/query-types/text.test-d.ts index 8dd7cbdef..f8e4b1ff1 100644 --- a/test/types/query-types/text.test-d.ts +++ b/test/types/query-types/text.test-d.ts @@ -1,4 +1,4 @@ -import { expectAssignable, expectNotAssignable, expectType } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntryFieldsEqualityFilter, @@ -16,53 +16,57 @@ import { // @ts-ignore import * as mocks from '../mocks' -expectAssignable>({}) -expectType>>({ - 'fields.testField[all]': mocks.stringArrayValue, -}) +test('text', async () => { + expectTypeOf>({}) + expectTypeOf>>({ + 'fields.testField[all]': mocks.stringArrayValue, + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField': mocks.stringValue, -}) + expectTypeOf>({}) + expectTypeOf>>( + { + 'fields.testField': mocks.stringValue, + }, + ) -expectAssignable>({}) -expectType>>({ - 'fields.testField[ne]': mocks.stringValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[ne]': mocks.stringValue, + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[exists]': mocks.booleanValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[exists]': mocks.booleanValue, + }) -expectAssignable>>({}) + expectTypeOf>>({}) -expectAssignable>>( - {}, -) + expectTypeOf>>({}) -expectAssignable>( - {}, -) -expectType< - Required> ->({ - 'fields.testField[match]': mocks.stringValue, -}) + expectTypeOf>({}) + expectTypeOf< + Required> + >({ + 'fields.testField[match]': mocks.stringValue, + }) -expectAssignable>({}) -expectNotAssignable>({ - order: ['fields.testField', '-fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf({ + order: ['fields.testField', '-fields.testField'], + }).not.toEqualTypeOf>() -expectAssignable>({}) -expectAssignable>>({ - select: ['fields.testField'], -}) + expectTypeOf>({}) + expectTypeOf>>({ + select: ['fields.testField'], + }) -expectAssignable>({}) -expectType>>({ - 'fields.testField[in]': mocks.stringArrayValue, - 'fields.testField[nin]': mocks.stringArrayValue, + expectTypeOf>({}) + expectTypeOf>>({ + 'fields.testField[in]': mocks.stringArrayValue, + 'fields.testField[nin]': mocks.stringArrayValue, + }) }) diff --git a/test/types/query.test-d.ts b/test/types/query.test-d.ts index 4cbddf20d..a961840be 100644 --- a/test/types/query.test-d.ts +++ b/test/types/query.test-d.ts @@ -1,124 +1,128 @@ -import { expectAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntriesQueries, EntryFieldTypes, EntrySkeletonType, EntryFieldsQueries } from '../../lib' // @ts-ignore import * as mocks from './mocks' -expectAssignable>>({ - select: ['fields.stringField'], - 'fields.stringField[exists]': mocks.booleanValue, - 'fields.stringField': mocks.stringValue, - 'fields.stringField[ne]': mocks.stringValue, - 'fields.stringField[in]': [mocks.stringValue], - 'fields.stringField[nin]': [mocks.stringValue], - 'fields.stringField[match]': mocks.stringValue, -}) +test('query', async () => { + expectTypeOf>>({ + select: ['fields.stringField'], + 'fields.stringField[exists]': mocks.booleanValue, + 'fields.stringField': mocks.stringValue, + 'fields.stringField[ne]': mocks.stringValue, + 'fields.stringField[in]': [mocks.stringValue], + 'fields.stringField[nin]': [mocks.stringValue], + 'fields.stringField[match]': mocks.stringValue, + }) -expectAssignable>>({ - select: ['fields.numberField'], - 'fields.numberField[exists]': mocks.booleanValue, - 'fields.numberField': mocks.numberValue, - 'fields.numberField[ne]': mocks.numberValue, - 'fields.numberField[in]': [mocks.numberValue], - 'fields.numberField[nin]': [mocks.numberValue], - 'fields.numberField[lt]': mocks.numberValue, - 'fields.numberField[lte]': mocks.numberValue, - 'fields.numberField[gt]': mocks.numberValue, - 'fields.numberField[gte]': mocks.numberValue, -}) + expectTypeOf>>({ + select: ['fields.numberField'], + 'fields.numberField[exists]': mocks.booleanValue, + 'fields.numberField': mocks.numberValue, + 'fields.numberField[ne]': mocks.numberValue, + 'fields.numberField[in]': [mocks.numberValue], + 'fields.numberField[nin]': [mocks.numberValue], + 'fields.numberField[lt]': mocks.numberValue, + 'fields.numberField[lte]': mocks.numberValue, + 'fields.numberField[gt]': mocks.numberValue, + 'fields.numberField[gte]': mocks.numberValue, + }) -expectAssignable>>({ - select: ['fields.integerField'], - 'fields.integerField[exists]': mocks.booleanValue, - 'fields.integerField': mocks.numberValue, - 'fields.integerField[ne]': mocks.numberValue, - 'fields.integerField[in]': [mocks.numberValue], - 'fields.integerField[nin]': [mocks.numberValue], - 'fields.integerField[lt]': mocks.numberValue, - 'fields.integerField[lte]': mocks.numberValue, - 'fields.integerField[gt]': mocks.numberValue, - 'fields.integerField[gte]': mocks.numberValue, -}) + expectTypeOf>>({ + select: ['fields.integerField'], + 'fields.integerField[exists]': mocks.booleanValue, + 'fields.integerField': mocks.numberValue, + 'fields.integerField[ne]': mocks.numberValue, + 'fields.integerField[in]': [mocks.numberValue], + 'fields.integerField[nin]': [mocks.numberValue], + 'fields.integerField[lt]': mocks.numberValue, + 'fields.integerField[lte]': mocks.numberValue, + 'fields.integerField[gt]': mocks.numberValue, + 'fields.integerField[gte]': mocks.numberValue, + }) -expectAssignable>>({ - select: ['fields.symbolField'], - 'fields.symbolField[exists]': mocks.booleanValue, - 'fields.symbolField': mocks.stringValue, - 'fields.symbolField[ne]': mocks.stringValue, - 'fields.symbolField[in]': [mocks.stringValue], - 'fields.symbolField[nin]': [mocks.stringValue], - 'fields.symbolField[match]': mocks.stringValue, -}) + expectTypeOf>>({ + select: ['fields.symbolField'], + 'fields.symbolField[exists]': mocks.booleanValue, + 'fields.symbolField': mocks.stringValue, + 'fields.symbolField[ne]': mocks.stringValue, + 'fields.symbolField[in]': [mocks.stringValue], + 'fields.symbolField[nin]': [mocks.stringValue], + 'fields.symbolField[match]': mocks.stringValue, + }) -expectAssignable>>({ - select: ['fields.dateField'], - 'fields.dateField[exists]': mocks.booleanValue, - 'fields.dateField': mocks.dateValue, - 'fields.dateField[ne]': mocks.dateValue, - 'fields.dateField[in]': [mocks.dateValue], - 'fields.dateField[nin]': [mocks.dateValue], - 'fields.dateField[match]': mocks.dateValue, // Date is a string type so Typescript will allow the match filter on it. - 'fields.dateField[lt]': mocks.dateValue, - 'fields.dateField[lte]': mocks.dateValue, - 'fields.dateField[gt]': mocks.dateValue, - 'fields.dateField[gte]': mocks.dateValue, -}) + expectTypeOf>>({ + select: ['fields.dateField'], + 'fields.dateField[exists]': mocks.booleanValue, + 'fields.dateField': mocks.dateValue, + 'fields.dateField[ne]': mocks.dateValue, + 'fields.dateField[in]': [mocks.dateValue], + 'fields.dateField[nin]': [mocks.dateValue], + 'fields.dateField[match]': mocks.dateValue, // Date is a string type so Typescript will allow the match filter on it. + 'fields.dateField[lt]': mocks.dateValue, + 'fields.dateField[lte]': mocks.dateValue, + 'fields.dateField[gt]': mocks.dateValue, + 'fields.dateField[gte]': mocks.dateValue, + }) -expectAssignable>>({ - select: ['fields.locationField'], - 'fields.locationField[exists]': mocks.booleanValue, - 'fields.locationField[near]': [34, 35], - 'fields.locationField[within]': [34, 35, 37, 38], -}) + expectTypeOf>>({ + select: ['fields.locationField'], + 'fields.locationField[exists]': mocks.booleanValue, + 'fields.locationField[near]': [34, 35], + 'fields.locationField[within]': [34, 35, 37, 38], + }) -expectAssignable>>({ - select: ['fields.objectField'], - 'fields.objectField[exists]': mocks.booleanValue, -}) + expectTypeOf>>({ + select: ['fields.objectField'], + 'fields.objectField[exists]': mocks.booleanValue, + }) -expectAssignable>>({ - select: ['fields.richTextField'], - 'fields.richTextField[exists]': mocks.booleanValue, - 'fields.richTextField[match]': mocks.stringValue, -}) + expectTypeOf>>({ + select: ['fields.richTextField'], + 'fields.richTextField[exists]': mocks.booleanValue, + 'fields.richTextField[match]': mocks.stringValue, + }) -expectAssignable< - Required }>> ->({ - select: ['fields.arrayStringField'], - 'fields.arrayStringField[exists]': mocks.booleanValue, - 'fields.arrayStringField': mocks.stringValue, - 'fields.arrayStringField[ne]': mocks.stringValue, - 'fields.arrayStringField[in]': [mocks.stringValue], - 'fields.arrayStringField[nin]': [mocks.stringValue], - 'fields.arrayStringField[match]': mocks.stringValue, -}) + expectTypeOf< + Required< + EntryFieldsQueries<{ arrayStringField: EntryFieldTypes.Array }> + > + >({ + select: ['fields.arrayStringField'], + 'fields.arrayStringField[exists]': mocks.booleanValue, + 'fields.arrayStringField': mocks.stringValue, + 'fields.arrayStringField[ne]': mocks.stringValue, + 'fields.arrayStringField[in]': [mocks.stringValue], + 'fields.arrayStringField[nin]': [mocks.stringValue], + 'fields.arrayStringField[match]': mocks.stringValue, + }) -expectAssignable< - Required }>> ->({ - select: ['fields.referenceField'], - 'fields.referenceField[exists]': mocks.booleanValue, - 'fields.referenceField.sys.contentType.sys.id': mocks.stringValue, - 'fields.referenceField.fields.numberField': mocks.numberValue, -}) + expectTypeOf< + Required }>> + >({ + select: ['fields.referenceField'], + 'fields.referenceField[exists]': mocks.booleanValue, + 'fields.referenceField.sys.contentType.sys.id': mocks.stringValue, + 'fields.referenceField.fields.numberField': mocks.numberValue, + }) -expectAssignable< - EntriesQueries< - EntrySkeletonType<{ - stringField: EntryFieldTypes.Symbol - numberField: EntryFieldTypes.Number - }>, - undefined - > ->({ - content_type: 'id', - 'fields.stringField[exists]': mocks.booleanValue, - 'fields.stringField[match]': mocks.stringValue, - 'fields.numberField[gte]': mocks.numberValue, - select: ['fields.stringField', 'fields.numberField'], - limit: mocks.numberValue, - order: ['fields.stringField', '-fields.numberField'], - links_to_asset: mocks.stringValue, - links_to_entry: mocks.stringValue, -}) + expectTypeOf< + EntriesQueries< + EntrySkeletonType<{ + stringField: EntryFieldTypes.Symbol + numberField: EntryFieldTypes.Number + }>, + undefined + > + >({ + content_type: 'id', + 'fields.stringField[exists]': mocks.booleanValue, + 'fields.stringField[match]': mocks.stringValue, + 'fields.numberField[gte]': mocks.numberValue, + select: ['fields.stringField', 'fields.numberField'], + limit: mocks.numberValue, + order: ['fields.stringField', '-fields.numberField'], + links_to_asset: mocks.stringValue, + links_to_entry: mocks.stringValue, + }) +}) \ No newline at end of file diff --git a/test/types/resolved-field.test-d.ts b/test/types/resolved-field.test-d.ts index 9f3ff8dee..29eb54806 100644 --- a/test/types/resolved-field.test-d.ts +++ b/test/types/resolved-field.test-d.ts @@ -1,8 +1,4 @@ -// As tsd does not pick up the global.d.ts located in /lib we -// explicitly reference it here once. -// eslint-disable-next-line @typescript-eslint/triple-slash-reference -/// -import { expectAssignable, expectNotAssignable } from 'tsd' +import { expectTypeOf, test } from "vitest"; import { EntryFieldTypes, EntrySkeletonType, ResolvedField } from '../../lib' // @ts-ignore @@ -11,540 +7,557 @@ import * as mocks from './mocks' type SimpleEntryFields = { title: EntryFieldTypes.Symbol } type SimpleEntryWithContentTypeId = EntrySkeletonType -expectAssignable>(mocks.stringValue) -expectAssignable, undefined>>('a') -expectAssignable, undefined>>('b') -expectNotAssignable, undefined>>('c') -expectAssignable>(mocks.stringValue) -expectAssignable, undefined>>('a') -expectAssignable, undefined>>('b') -expectNotAssignable, undefined>>('c') +test('resolved-field', async () => { + expectTypeOf>(mocks.stringValue) + expectTypeOf, undefined>>('a') + expectTypeOf, undefined>>('b') + expectTypeOf('c').not.toEqualTypeOf, undefined>>() -expectAssignable>(mocks.numberValue) -expectAssignable, undefined>>(1) -expectAssignable, undefined>>(2) -expectNotAssignable, undefined>>(3) + expectTypeOf>(mocks.stringValue) + expectTypeOf, undefined>>('a') + expectTypeOf, undefined>>('b') + expectTypeOf('c').not.toEqualTypeOf, undefined>>() -expectAssignable>(mocks.numberValue) -expectAssignable, undefined>>(1) -expectAssignable, undefined>>(2) -expectNotAssignable, undefined>>(3) + expectTypeOf>(mocks.numberValue) + expectTypeOf, undefined>>(1) + expectTypeOf, undefined>>(2) + expectTypeOf(3).not.toEqualTypeOf, undefined>>() -expectAssignable>(mocks.dateValue) -expectAssignable>(mocks.booleanValue) -expectAssignable>(mocks.locationValue) + expectTypeOf>(mocks.numberValue) + expectTypeOf, undefined>>(1) + expectTypeOf, undefined>>(2) + expectTypeOf(3).not.toEqualTypeOf, undefined>>() -expectAssignable, undefined>>([ - mocks.stringValue, -]) -expectAssignable< - ResolvedField>, undefined> ->(['a', 'b']) -expectNotAssignable< - ResolvedField>, undefined> ->(['c']) + expectTypeOf>(mocks.dateValue) + expectTypeOf>(mocks.booleanValue) + expectTypeOf>(mocks.locationValue) -expectAssignable>(mocks.jsonValue) + expectTypeOf, undefined>>([ + mocks.stringValue, + ]) + expectTypeOf>, undefined>>([ + 'a', + 'b', + ]) + expectTypeOf(['c']).not.toEqualTypeOf< + ResolvedField>, undefined> + >() -// entries in links + expectTypeOf>(mocks.jsonValue) -expectAssignable, undefined>>( - mocks.entry, -) -expectAssignable, undefined>>( - mocks.entryLink, -) -expectNotAssignable< - ResolvedField, undefined> ->(undefined) -expectNotAssignable< - ResolvedField, undefined> ->(mocks.asset) -expectNotAssignable< - ResolvedField, undefined> ->(mocks.assetLink) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entryLink]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryLink]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryLink, undefined]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryLink, mocks.asset]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryLink, mocks.assetLink]) + // entries in links -expectAssignable< - ResolvedField< - EntryFieldTypes.EntryLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.entry) -expectAssignable< - ResolvedField< - EntryFieldTypes.EntryLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(undefined) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.EntryLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.entryLink) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([undefined]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry, undefined]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry, mocks.entryLink, undefined]) + expectTypeOf, undefined>>( + mocks.entry, + ) + expectTypeOf, undefined>>( + mocks.entryLink, + ) + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf(mocks.asset).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf(mocks.assetLink).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >([mocks.entry]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >([mocks.entryLink]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >([mocks.entry, mocks.entryLink]) + expectTypeOf([mocks.entry, mocks.entryLink, undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >() + expectTypeOf([mocks.entry, mocks.entryLink, mocks.asset]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >() + expectTypeOf([mocks.entry, mocks.entryLink, mocks.assetLink]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >() -expectAssignable< - ResolvedField, 'WITHOUT_LINK_RESOLUTION'> ->(mocks.entryLink) -expectNotAssignable< - ResolvedField, 'WITHOUT_LINK_RESOLUTION'> ->(undefined) -expectNotAssignable< - ResolvedField, 'WITHOUT_LINK_RESOLUTION'> ->(mocks.entry) + expectTypeOf< + ResolvedField< + EntryFieldTypes.EntryLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(mocks.entry) + expectTypeOf< + ResolvedField< + EntryFieldTypes.EntryLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(undefined) + expectTypeOf(mocks.entryLink).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.EntryLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([mocks.entry]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([undefined]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([mocks.entry, undefined]) + expectTypeOf([mocks.entry, mocks.entryLink, undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() -// entries in resource links + expectTypeOf< + ResolvedField< + EntryFieldTypes.EntryLink, + 'WITHOUT_LINK_RESOLUTION' + > + >(mocks.entryLink) + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.EntryLink, + 'WITHOUT_LINK_RESOLUTION' + > + >() + expectTypeOf(mocks.entry).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.EntryLink, + 'WITHOUT_LINK_RESOLUTION' + > + >() -expectAssignable< - ResolvedField, undefined> ->(mocks.entry) -expectAssignable< - ResolvedField, undefined> ->(mocks.entryResourceLink) -expectNotAssignable< - ResolvedField, undefined> ->(undefined) -expectNotAssignable< - ResolvedField, undefined> ->(mocks.asset) -expectNotAssignable< - ResolvedField, undefined> ->(mocks.assetLink) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entryResourceLink]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryResourceLink]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryResourceLink, undefined]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryResourceLink, mocks.asset]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - undefined - > ->([mocks.entry, mocks.entryResourceLink, mocks.assetLink]) + // entries in resource links -expectAssignable< - ResolvedField< - EntryFieldTypes.EntryResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.entry) -expectAssignable< - ResolvedField< - EntryFieldTypes.EntryResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(undefined) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.EntryResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.entryResourceLink) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([undefined]) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry, undefined]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array>, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry, mocks.entryResourceLink, undefined]) + expectTypeOf< + ResolvedField, undefined> + >(mocks.entry) + expectTypeOf< + ResolvedField, undefined> + >(mocks.entryResourceLink) + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf(mocks.asset).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf(mocks.assetLink).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >([mocks.entry]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >([mocks.entryResourceLink]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >([mocks.entry, mocks.entryResourceLink]) + expectTypeOf([mocks.entry, mocks.entryResourceLink, undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >() + expectTypeOf([mocks.entry, mocks.entryResourceLink, mocks.asset]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >() + expectTypeOf([mocks.entry, mocks.entryResourceLink, mocks.assetLink]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + undefined + > + >() -expectAssignable< - ResolvedField< - EntryFieldTypes.EntryResourceLink, - 'WITHOUT_LINK_RESOLUTION' - > ->(mocks.entryResourceLink) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.EntryResourceLink, - 'WITHOUT_LINK_RESOLUTION' - > ->(undefined) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.EntryResourceLink, - 'WITHOUT_LINK_RESOLUTION' - > ->(mocks.entry) + expectTypeOf< + ResolvedField< + EntryFieldTypes.EntryResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(mocks.entry) + expectTypeOf< + ResolvedField< + EntryFieldTypes.EntryResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(undefined) + expectTypeOf(mocks.entryResourceLink).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.EntryResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([mocks.entry]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([undefined]) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([mocks.entry, undefined]) + expectTypeOf([mocks.entry, mocks.entryResourceLink, undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array>, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() -// external resource links + expectTypeOf< + ResolvedField< + EntryFieldTypes.EntryResourceLink, + 'WITHOUT_LINK_RESOLUTION' + > + >(mocks.entryResourceLink) + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.EntryResourceLink, + 'WITHOUT_LINK_RESOLUTION' + > + >() + expectTypeOf(mocks.entry).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.EntryResourceLink, + 'WITHOUT_LINK_RESOLUTION' + > + >() -expectAssignable>( - mocks.externalResourceLink, -) -// assignable because 'Contentful:Entry' is a subtype of string -expectAssignable>( - mocks.entryResourceLink, -) -expectNotAssignable>(mocks.entry) -expectNotAssignable>(undefined) -expectNotAssignable>(mocks.asset) -expectNotAssignable>(mocks.assetLink) -expectAssignable< - ResolvedField, undefined> ->([mocks.externalResourceLink, mocks.entryResourceLink]) -expectNotAssignable< - ResolvedField, undefined> ->([mocks.entry]) -expectNotAssignable< - ResolvedField, undefined> ->([mocks.externalResourceLink, undefined]) -expectNotAssignable< - ResolvedField, undefined> ->([mocks.externalResourceLink, mocks.asset]) -expectNotAssignable< - ResolvedField, undefined> ->([mocks.externalResourceLink, mocks.assetLink]) + // external resource links -expectAssignable>( - mocks.externalResourceLink, -) -// assignable because 'Contentful:Entry' is a subtype of string -expectAssignable>( - mocks.entryResourceLink, -) -expectNotAssignable< - ResolvedField ->(mocks.entry) -expectNotAssignable< - ResolvedField ->(undefined) -expectNotAssignable< - ResolvedField ->(mocks.asset) -expectNotAssignable< - ResolvedField ->(mocks.assetLink) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.externalResourceLink, mocks.entryResourceLink]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.externalResourceLink, undefined]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.externalResourceLink, mocks.asset]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.externalResourceLink, mocks.assetLink]) + expectTypeOf>( + mocks.externalResourceLink, + ) + // assignable because 'Contentful:Entry' is a subtype of string + expectTypeOf>( + mocks.entryResourceLink, + ) + expectTypeOf(mocks.entry).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(mocks.asset).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(mocks.assetLink).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf< + ResolvedField, undefined> + >([mocks.externalResourceLink, mocks.entryResourceLink]) + expectTypeOf([mocks.entry]).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf([mocks.externalResourceLink, undefined]).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf([mocks.externalResourceLink, mocks.asset]).not.toEqualTypeOf< + ResolvedField, undefined> + >() + expectTypeOf([mocks.externalResourceLink, mocks.assetLink]).not.toEqualTypeOf< + ResolvedField, undefined> + >() -expectAssignable>( - mocks.externalResourceLink, -) -// assignable because 'Contentful:Entry' is a subtype of string -expectAssignable>( - mocks.entryResourceLink, -) -expectNotAssignable>( - mocks.entry, -) -expectNotAssignable>( - undefined, -) -expectNotAssignable>( - mocks.asset, -) -expectNotAssignable>( - mocks.assetLink, -) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_LINK_RESOLUTION' - > ->([mocks.externalResourceLink, mocks.entryResourceLink]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_LINK_RESOLUTION' - > ->([mocks.entry]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_LINK_RESOLUTION' - > ->([undefined]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_LINK_RESOLUTION' - > ->([mocks.asset]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array, - 'WITHOUT_LINK_RESOLUTION' - > ->([mocks.assetLink]) + expectTypeOf>( + mocks.externalResourceLink, + ) + // assignable because 'Contentful:Entry' is a subtype of string + expectTypeOf>( + mocks.entryResourceLink, + ) + expectTypeOf(mocks.entry).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(mocks.asset).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(mocks.assetLink).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([mocks.externalResourceLink, mocks.entryResourceLink]) + expectTypeOf([mocks.entry]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + expectTypeOf([mocks.externalResourceLink, undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + expectTypeOf([mocks.externalResourceLink, mocks.asset]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() + expectTypeOf([mocks.externalResourceLink, mocks.assetLink]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >() -// mixed resource links + expectTypeOf>( + mocks.externalResourceLink, + ) + // assignable because 'Contentful:Entry' is a subtype of string + expectTypeOf>( + mocks.entryResourceLink, + ) + expectTypeOf(mocks.entry).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(mocks.asset).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf(mocks.assetLink).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_LINK_RESOLUTION' + > + >([mocks.externalResourceLink, mocks.entryResourceLink]) + expectTypeOf([mocks.entry]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_LINK_RESOLUTION' + > + >() + expectTypeOf([undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_LINK_RESOLUTION' + > + >() + expectTypeOf([mocks.asset]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_LINK_RESOLUTION' + > + >() + expectTypeOf([mocks.assetLink]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array, + 'WITHOUT_LINK_RESOLUTION' + > + >() -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - undefined - > ->(mocks.entry) -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - undefined - > ->(mocks.entryResourceLink) -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - undefined - > ->(mocks.externalResourceLink) -expectNotAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - undefined - > ->(undefined) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array< + // mixed resource links + + expectTypeOf< + ResolvedField< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink, + undefined + > + >(mocks.entry) + expectTypeOf< + ResolvedField< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink, + undefined + > + >(mocks.entryResourceLink) + expectTypeOf< + ResolvedField< | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink - >, - undefined - > ->([mocks.entry, mocks.entryResourceLink, mocks.externalResourceLink]) -expectNotAssignable< - ResolvedField< - EntryFieldTypes.Array< + | EntryFieldTypes.ExternalResourceLink, + undefined + > + >(mocks.externalResourceLink) + expectTypeOf(undefined).not.toEqualTypeOf< + ResolvedField< | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink - >, - undefined - > ->([undefined]) + | EntryFieldTypes.ExternalResourceLink, + undefined + > + >() + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink + >, + undefined + > + >([mocks.entry, mocks.entryResourceLink, mocks.externalResourceLink]) + expectTypeOf([undefined]).not.toEqualTypeOf< + ResolvedField< + EntryFieldTypes.Array< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink + >, + undefined + > + >() -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.entry) -// assignable because 'Contentful:Entry' is a subtype of string -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.entryResourceLink) -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(mocks.externalResourceLink) -expectAssignable< - ResolvedField< - | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->(undefined) -expectAssignable< - ResolvedField< - EntryFieldTypes.Array< + expectTypeOf< + ResolvedField< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(mocks.entry) + // assignable because 'Contentful:Entry' is a subtype of string + expectTypeOf< + ResolvedField< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(mocks.entryResourceLink) + expectTypeOf< + ResolvedField< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(mocks.externalResourceLink) + expectTypeOf< + ResolvedField< | EntryFieldTypes.EntryResourceLink - | EntryFieldTypes.ExternalResourceLink - >, - 'WITHOUT_UNRESOLVABLE_LINKS' - > ->([mocks.entry, mocks.entryResourceLink, mocks.externalResourceLink, undefined]) + | EntryFieldTypes.ExternalResourceLink, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >(undefined) + expectTypeOf< + ResolvedField< + EntryFieldTypes.Array< + | EntryFieldTypes.EntryResourceLink + | EntryFieldTypes.ExternalResourceLink + >, + 'WITHOUT_UNRESOLVABLE_LINKS' + > + >([mocks.entry, mocks.entryResourceLink, mocks.externalResourceLink, undefined]) -// assets + // assets -expectAssignable>(mocks.asset) -expectAssignable>(mocks.assetLink) -expectNotAssignable>(undefined) -expectNotAssignable>(mocks.entry) -expectNotAssignable>(mocks.entryLink) -expectAssignable, undefined>>([ - mocks.asset, -]) -expectAssignable, undefined>>([ - mocks.assetLink, -]) -expectAssignable, undefined>>([ - mocks.asset, - mocks.assetLink, -]) -expectNotAssignable, undefined>>([ - mocks.asset, - mocks.assetLink, - undefined, -]) + expectTypeOf>(mocks.asset) + expectTypeOf>(mocks.assetLink) + expectTypeOf(undefined).not.toEqualTypeOf>() + expectTypeOf(mocks.entry).not.toEqualTypeOf>() + expectTypeOf(mocks.entryLink).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf, undefined>>([ + mocks.asset, + ]) + expectTypeOf, undefined>>([ + mocks.assetLink, + ]) + expectTypeOf, undefined>>([ + mocks.asset, + mocks.assetLink, + ]) + expectTypeOf([mocks.asset, mocks.assetLink, undefined]).not.toEqualTypeOf< + ResolvedField, undefined> + >() -expectAssignable>( - mocks.asset, -) -expectAssignable>(undefined) -expectNotAssignable>( - mocks.assetLink, -) -expectAssignable< - ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> ->([mocks.asset]) -expectAssignable< - ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> ->([undefined]) -expectAssignable< - ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> ->([mocks.asset, undefined]) -expectNotAssignable< - ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> ->([mocks.assetLink, mocks.asset, undefined]) -expectNotAssignable< - ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> ->([mocks.assetLink, mocks.asset, mocks.entry]) -expectNotAssignable< - ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> ->([mocks.assetLink, mocks.asset, mocks.entryLink]) + expectTypeOf>(mocks.asset) + expectTypeOf>(undefined) + expectTypeOf(mocks.assetLink).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf< + ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> + >([mocks.asset]) + expectTypeOf< + ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> + >([undefined]) + expectTypeOf< + ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> + >([mocks.asset, undefined]) + expectTypeOf([mocks.assetLink, mocks.asset, undefined]).not.toEqualTypeOf< + ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> + >() + expectTypeOf([mocks.assetLink, mocks.asset, mocks.entry]).not.toEqualTypeOf< + ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> + >() + expectTypeOf([mocks.assetLink, mocks.asset, mocks.entryLink]).not.toEqualTypeOf< + ResolvedField, 'WITHOUT_UNRESOLVABLE_LINKS'> + >() -expectAssignable>( - mocks.assetLink, -) -expectNotAssignable>( - mocks.asset, -) -expectAssignable< - ResolvedField, 'WITHOUT_LINK_RESOLUTION'> ->([mocks.assetLink]) -expectNotAssignable< - ResolvedField, 'WITHOUT_LINK_RESOLUTION'> ->([mocks.asset]) + expectTypeOf>(mocks.assetLink) + expectTypeOf(mocks.asset).not.toEqualTypeOf< + ResolvedField + >() + expectTypeOf< + ResolvedField, 'WITHOUT_LINK_RESOLUTION'> + >([mocks.assetLink]) + expectTypeOf([mocks.asset]).not.toEqualTypeOf< + ResolvedField, 'WITHOUT_LINK_RESOLUTION'> + >() +}) \ No newline at end of file diff --git a/vitest.config.ts b/vitest.config.ts index db4fc9665..75ed86b96 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -7,6 +7,10 @@ export default defineConfig({ coverage: { include: ['lib/**/*.{ts,tsx,js,jsx}'], }, - setupFiles: ['./vitest.setup.ts'], + // @todo In a future version of Vitest, we hope to be able to set these options to our integration tests through Vitest workspaces. + // Currently, we’re specifying them in the package.json CLI parameters. + // maxWorkers: 3, + // minWorkers: 1, + // fileParallelism: false, }, }) diff --git a/vitest.setup.browser.ts b/vitest.setup.browser.ts new file mode 100644 index 000000000..b56b956f0 --- /dev/null +++ b/vitest.setup.browser.ts @@ -0,0 +1 @@ +window.global ||= window diff --git a/vitest.setup.unit.ts b/vitest.setup.unit.ts new file mode 100644 index 000000000..34a3d9c7c --- /dev/null +++ b/vitest.setup.unit.ts @@ -0,0 +1,15 @@ +import { vi } from 'vitest' +import type contentfulSdkCore from 'contentful-sdk-core' + +vi.mock('contentful-sdk-core', async (importOriginal) => { + const orig = await importOriginal() + return { + ...orig, + createHttpClient: vi + .fn() + .mockImplementation(() => ({ + defaults: { baseURL: 'mocked' }, + get: vi.fn(() => ({ data: { sys: {id: "mocked"}} })), + })), + } +}) diff --git a/vitest.workspace.js b/vitest.workspace.js new file mode 100644 index 000000000..676fb0981 --- /dev/null +++ b/vitest.workspace.js @@ -0,0 +1,85 @@ +import { defineWorkspace } from 'vitest/config' +import vitestConfig from './vitest.config' + +export default defineWorkspace([ + { + test: { + ...vitestConfig.test, + include: ['test/output-integration/**/*.{test,spec}.ts'], + name: 'output', + setupFiles: ['./vitest.setup.ts'], + environment: 'node', + maxConcurrency: 10, + }, + }, + { + test: { + ...vitestConfig.test, + include: ['test/unit/**/*.{test,spec}.ts'], + name: 'unit', + setupFiles: ['./vitest.setup.ts', './vitest.setup.unit.ts'], + environment: 'node', + maxConcurrency: 10, + }, + }, + { + test: { + ...vitestConfig.test, + include: ['test/types/**/*.test-d.ts'], + name: 'types', + setupFiles: ['./vitest.setup.ts', './vitest.setup.unit.ts'], + maxConcurrency: 10, + typecheck: { + enabled: true, + }, + }, + }, + { + test: { + ...vitestConfig.test, + include: ['test/integration/**/*.{test,spec}.ts'], + name: 'integration', + setupFiles: ['./vitest.setup.ts'], + environment: 'node', + maxConcurrency: 1, + testTimeout: 60000, + hookTimeout: 60000, + bail: 100, + }, + teardownTimeout: 120000, + slowTestThreshold: 1000, + }, + { + test: { + ...vitestConfig.test, + include: ['test/unit/**/*.{test,spec}.ts'], + name: 'browser-unit', + setupFiles: ['./vitest.setup.browser.ts', './vitest.setup.ts', './vitest.setup.unit.ts'], + maxConcurrency: 10, + browser: { + enabled: true, + provider: 'playwright', + name: 'chromium', + }, + }, + }, + { + test: { + ...vitestConfig.test, + include: ['test/integration/**/*.{test,spec}.ts'], + name: 'browser-integration', + setupFiles: ['./vitest.setup.browser.ts', './vitest.setup.ts'], + browser: { + enabled: true, + provider: 'playwright', + name: 'chromium', + }, + maxConcurrency: 1, + testTimeout: 60000, + hookTimeout: 60000, + bail: 100, + }, + teardownTimeout: 120000, + slowTestThreshold: 1000, + }, +])