@sanity/client 6.4.10-canary.3 → 6.4.10-dev.0

package/dist/index.cjs

@@ -8,7 +8,7 @@ var getIt = require('get-it');
 var rxjs = require('rxjs');
 var operators = require('rxjs/operators');
 var name = "@sanity/client";
-var version = "6.4.10-canary.3";
+var version = "6.4.10-dev.0";
 const middleware = [middleware$1.debug({
   verbose: true,
   namespace: "sanity:client"

package/dist/index.d.ts

@@ -2215,6 +2215,81 @@ export declare interface SingleMutationResult {
   }[]
 }
 
+/**
+ * Stricter typing of the response from `client.fetch`, intended to be used by type inference libraries and tooling that
+ * delivers runtime safety in production.
+ *
+ * @example
+ * It's not designed to be used directly in application code, in fact that would be the most annoying way to query Content Lake in a runtime safe way:
+ * ```ts
+ * import type {StrictUnknownQueryResponseResult} from '@sanity/client'
+ * const query = '*[_type == "product"]'
+ * const response = client.fetch<StrictUnknownQueryResponseResult>(query)
+ * // Response is now strictly typed, without any knowledge of the dataset or what the GROQ query might return.
+ * // The GROQ query is asking for an array of documents that have `_type` = "product", but TypeScript doesn't know that,
+ * // `query` is `string` and so the type accounts for anything that GROQ supports, which means you might have any JSON valid data in the response.
+ * // \@ts-expect-error -- TS doesn't know the api will always return an array, so it errors
+ * console.log(response.length)
+ * // It needs a runtime check to ensure it's an array
+ * if (Array.isArray(response)) console.log(response.length)
+ * ```
+ *
+ * @example
+ * How's it intended to be used? By libraries that delivers end-to-end GROQ runtime type safety.
+ * For example in an imaginary TypeScript language service plugin that can look at your `sanity.config.ts`:
+ * ```ts
+ * import { defineConfig } from 'sanity'
+
+ *  export default defineConfig({
+ *    projectId: '...',
+ *    dataset: '...',
+ *    schema: {
+ *      types: [
+ *        {
+ *          name: 'page',
+ *          title: 'Page',
+ *          type: 'document',
+ *          fields: [
+ *            {
+ *              name: 'title',
+ *              title: 'Title',
+ *              type: 'string',
+ *            },
+ *          ],
+ *        },
+ *      ],
+ *    },
+ *  })
+ * ```
+ * And use that to infer typings:
+ * ```ts
+ * import {createClient} from '@sanity/client'
+ *
+ * const client = createClient()
+ * const response = client.fetch('*[_type == "page"]')
+ * // all is well, if title exists the schema says it's a string
+ * response.map(page => page.title?.toUpperCase())
+ * // IDE flags an error, the `author` property isn't defined in the schema so it could be any JSON valid value.
+ * response.map(page => page.author?.toUpperCase())
+ * // Maybe this is by design because `author` is coming from an external source, and not from entering it in the Studio interface,
+ * // the IDE plugin returns `StrictUnknownQueryResponseResult` and you have to handle it manually:
+ * response.map(page => typeof page.author === 'string' ? page.author.toUpperCase() : 'UNKNOWN')
+ * ```
+ * If the imaginary IDE extension returned `any` or `unknown` instead of `StrictUnknownQueryResponseResult` it opens up a lot of
+ * possibilities where it would fail silently and instead error at runtime.
+ *
+ * @public
+ */
+export declare type StrictUnknownQueryResponseResult =
+  | string
+  | number
+  | boolean
+  | null
+  | {
+      [key: string]: StrictUnknownQueryResponseResult | undefined
+    }
+  | StrictUnknownQueryResponseResult[]
+
 /** @public */
 export declare class Transaction extends BaseTransaction {
   #private

package/dist/index.js

@@ -4,7 +4,7 @@ export { adapter as unstable__adapter, environment as unstable__environment } fr
 import { Observable, lastValueFrom } from 'rxjs';
 import { map, filter } from 'rxjs/operators';
 var name = "@sanity/client";
-var version = "6.4.10-canary.3";
+var version = "6.4.10-dev.0";
 const middleware = [debug({
   verbose: true,
   namespace: "sanity:client"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "6.4.10-canary.3",
+  "version": "6.4.10-dev.0",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "keywords": [
     "sanity",
@@ -40,9 +40,10 @@
       "source": "./src/index.ts",
       "require": "./dist/index.cjs",
       "node": {
+        "module": "./dist/index.js",
         "import": "./dist/index.cjs.js"
       },
-      "module": "./dist/index.js",
+      "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
@@ -71,7 +72,7 @@
     "prepublishOnly": "npm run build",
     "rollup": "NODE_ENV=production rollup -c rollup.config.cjs",
     "test": "vitest",
-    "type-check": "tsc --noEmit",
+    "type-check": "tsc --noEmit && vitest typecheck",
     "test:browser": "npm test -- --config ./vitest.browser.config.ts",
     "test:bun": "(cd runtimes/bun && bun wiptest)",
     "test:deno": "deno test --allow-read --allow-net --allow-env --fail-fast --import-map=runtimes/deno/import_map.json runtimes/deno",
@@ -105,7 +106,7 @@
     "@types/node": "^20.5.9",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
-    "@vitest/coverage-v8": "^0.34.3",
+    "@vitest/coverage-v8": "0.34.3",
     "eslint": "^8.48.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-prettier": "^5.0.0",
@@ -121,13 +122,14 @@
     "sse-channel": "^4.0.0",
     "terser": "^5.19.3",
     "typescript": "^5.2.2",
-    "vitest": "^0.34.3",
-    "vitest-github-actions-reporter": "^0.10.0"
+    "vitest": "0.34.3",
+    "vitest-github-actions-reporter": "0.10.0"
   },
   "engines": {
     "node": ">=14.18"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": false
   }
 }

package/src/types.ts

@@ -518,6 +518,79 @@ export type UnfilteredResponseQueryOptions = ResponseQueryOptions & {
   filterResponse: false
 }
 
+/**
+ * Stricter typing of the response from `client.fetch`, intended to be used by type inference libraries and tooling that
+ * delivers runtime safety in production.
+ *
+ * @example
+ * It's not designed to be used directly in application code, in fact that would be the most annoying way to query Content Lake in a runtime safe way:
+ * ```ts
+ * import type {StrictUnknownQueryResponseResult} from '@sanity/client'
+ * const query = '*[_type == "product"]'
+ * const response = client.fetch<StrictUnknownQueryResponseResult>(query)
+ * // Response is now strictly typed, without any knowledge of the dataset or what the GROQ query might return.
+ * // The GROQ query is asking for an array of documents that have `_type` = "product", but TypeScript doesn't know that, 
+ * // `query` is `string` and so the type accounts for anything that GROQ supports, which means you might have any JSON valid data in the response.
+ * // \@ts-expect-error -- TS doesn't know the api will always return an array, so it errors
+ * console.log(response.length)
+ * // It needs a runtime check to ensure it's an array
+ * if (Array.isArray(response)) console.log(response.length)
+ * ```
+ * 
+ * @example
+ * How's it intended to be used? By libraries that delivers end-to-end GROQ runtime type safety.
+ * For example in an imaginary TypeScript language service plugin that can look at your `sanity.config.ts`:
+ * ```ts
+ * import { defineConfig } from 'sanity'
+
+*  export default defineConfig({
+*    projectId: '...',
+*    dataset: '...',
+*    schema: {
+*      types: [
+*        {
+*          name: 'page',
+*          title: 'Page',
+*          type: 'document',
+*          fields: [
+*            {
+*              name: 'title',
+*              title: 'Title',
+*              type: 'string',
+*            },
+*          ],
+*        },
+*      ],
+*    },
+*  })
+ * ```
+ * And use that to infer typings:
+ * ```ts
+ * import {createClient} from '@sanity/client'
+ * 
+ * const client = createClient()
+ * const response = client.fetch('*[_type == "page"]')
+ * // all is well, if title exists the schema says it's a string
+ * response.map(page => page.title?.toUpperCase())
+ * // IDE flags an error, the `author` property isn't defined in the schema so it could be any JSON valid value.
+ * response.map(page => page.author?.toUpperCase())
+ * // Maybe this is by design because `author` is coming from an external source, and not from entering it in the Studio interface,
+ * // the IDE plugin returns `StrictUnknownQueryResponseResult` and you have to handle it manually:
+ * response.map(page => typeof page.author === 'string' ? page.author.toUpperCase() : 'UNKNOWN')
+ * ```
+ * If the imaginary IDE extension returned `any` or `unknown` instead of `StrictUnknownQueryResponseResult` it opens up a lot of 
+ * possibilities where it would fail silently and instead error at runtime.
+ * 
+ * @public
+ */
+export type StrictUnknownQueryResponseResult =
+  | string
+  | number
+  | boolean
+  | null
+  | {[key: string]: StrictUnknownQueryResponseResult | undefined}
+  | StrictUnknownQueryResponseResult[]
+
 /** @public */
 export interface RawQueryResponse<R> {
   query: string