@sanity/sdk 0.0.0-alpha.16 → 0.0.0-alpha.17

package/dist/index.d.ts

@@ -20,7 +20,6 @@ import {SanityClient} from '@sanity/client'
 import {SanityDocument} from '@sanity/types'
 import {SanityDocumentLike} from '@sanity/types'
 import {SanityProject as SanityProject_2} from '@sanity/client'
-import {SchemaTypeDefinition} from '@sanity/types'
 import {Subject} from 'rxjs'
 
 declare interface AccessAttributeNode extends BaseNode {
@@ -303,6 +302,7 @@ export declare interface AuthStoreState {
     callbackUrl: string | undefined
     providedToken: string | undefined
   }
+  dashboardContext?: DashboardContext
 }
 
 /** The base interface for SyntaxNode. */
@@ -481,6 +481,17 @@ export declare const createUsersStore: (instance: SanityInstance | ActionContext
 
 export {CurrentUser}
 
+/**
+ * Represents the various states the authentication can be in.
+ *
+ * @public
+ */
+declare interface DashboardContext {
+  mode?: string
+  env?: string
+  orgId?: string | object
+}
+
 declare class DateTime {
   date: Date
   constructor(date: Date)
@@ -1524,6 +1535,17 @@ declare interface PosNode extends BaseNode {
   base: ExprNode
 }
 
+/**
+ * Represents a media asset in a preview.
+ *
+ * @public
+ */
+declare interface PreviewMedia {
+  type: 'image-asset'
+  _ref: string
+  url: string
+}
+
 /**
  * @public
  */
@@ -1561,10 +1583,7 @@ export declare interface PreviewValue {
    * An optional piece of media representing the document within its preview.
    * Currently, only image assets are available.
    */
-  media?: {
-    type: 'image-asset'
-    url: string
-  } | null
+  media?: PreviewMedia | null
   /**
    * The status of the document.
    */
@@ -1818,7 +1837,6 @@ export declare interface SanityConfig {
   projectId: string
   dataset: string
   auth?: AuthConfig
-  schema?: SchemaConfig
 }
 
 export {SanityDocument}
@@ -1859,13 +1877,6 @@ declare interface SanityUserResponse {
   nextCursor: string | null
 }
 
-/**
- * @public
- */
-export declare interface SchemaConfig {
-  types: SchemaTypeDefinition[]
-}
-
 declare class Scope {
   params: Record<string, unknown>
   source: Value

package/dist/index.js

@@ -3,8 +3,7 @@ import { devtools } from "zustand/middleware";
 import { createStore as createStore$1 } from "zustand/vanilla";
 import { createClient } from "@sanity/client";
 import { createSelector } from "reselect";
-import { noop, omit, isEqual } from "lodash-es";
-import { Schema } from "@sanity/schema";
+import { noop, omit, isObject, isEqual } from "lodash-es";
 import { createController, createNode } from "@sanity/comlink";
 import { SanityEncoder } from "@sanity/mutate";
 import { getPublishedId as getPublishedId$1 } from "@sanity/client/csm";
@@ -583,13 +582,13 @@ function generateArrayKey(length = 12) {
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, length);
 }
 function memoize(fn) {
-  const cache2 = /* @__PURE__ */ new WeakMap();
+  const cache = /* @__PURE__ */ new WeakMap();
   return (input) => {
     if (!input || typeof input != "object") return fn(input);
-    const cached = cache2.get(input);
+    const cached = cache.get(input);
     if (cached) return cached;
     const result = fn(input);
-    return cache2.set(input, result), result;
+    return cache.set(input, result), result;
   };
 }
 const ensureArrayKeysDeep = memoize((input) => {
@@ -890,8 +889,18 @@ const DEFAULT_API_VERSION = "2024-11-12", DEFAULT_REQUEST_TAG_PREFIX = "sanity.s
     if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken) return !1;
     const authCode = getAuthCode(callbackUrl, locationHref);
     if (!authCode) return !1;
+    const parsedUrl = new URL(locationHref);
+    let dashboardContext = {};
+    try {
+      const contextParam = parsedUrl.searchParams.get("_context") ?? "{}";
+      dashboardContext = JSON.parse(contextParam);
+    } catch (err) {
+      console.error("Failed to parse dashboard context:", err);
+    }
+    const { mode, env, orgId } = dashboardContext;
     state.set("exchangeSessionForToken", {
-      authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !0 }
+      authState: { type: AuthStateType.LOGGING_IN, isExchangingToken: !0 },
+      dashboardContext: { mode, env, orgId }
     });
     try {
       const client = clientFactory({
@@ -935,16 +944,7 @@ const DEFAULT_API_VERSION = "2024-11-12", DEFAULT_REQUEST_TAG_PREFIX = "sanity.s
       }), storageArea?.removeItem(storageKey);
     }
   };
-}), schemaManager = {
-  name: "schemaManager",
-  getInitialState(instance) {
-    const { config } = instance;
-    return { schema: Schema.compile({
-      name: "default",
-      types: config.schema?.types ?? []
-    }) };
-  }
-};
+});
 function createLiveEventSubscriber(tag) {
   return createInternalAction(({ instance, state }) => {
     const client$ = getClientState(instance, { apiVersion: "vX" }).observable, syncTags$ = state.observable.pipe(
@@ -972,73 +972,37 @@ function createLiveEventSubscriber(tag) {
     };
   });
 }
-const getSchemaState = createStateSourceAction(schemaManager, (state) => state.schema);
 function hashString(str) {
   let hash = 0;
   for (let i2 = 0; i2 < str.length; i2++)
     hash = (hash * 31 + str.charCodeAt(i2)) % 2147483647;
   return Math.abs(hash).toString(16).padStart(8, "0");
 }
-function getProjectionForSchemaType(schema, schemaTypeName) {
-  const schemaType = schema.get(schemaTypeName);
-  if (!schemaType)
-    throw new Error(`Could not find type \`${schemaTypeName}\` in the provided schema.`);
-  return `{${Object.entries(schemaType.preview?.select ?? {}).map(([key, path]) => `${JSON.stringify(key)}:${getGroqFromPath(schema, schemaType, path)}`).join(",")}}`;
-}
-function isReferenceType(type, visited = /* @__PURE__ */ new Set()) {
-  return !type || visited.has(type) ? !1 : (visited.add(type), type.name === "reference" ? !0 : isReferenceType(type.type, visited));
-}
-function printPath(segments) {
-  return segments.reduce((acc, segment) => segment.type === "deref" ? `${acc}->` : segment.type === "element" ? `${acc}[${segment.index}]` : acc.endsWith("->") ? `${acc}${segment.name}` : [acc, segment.name].filter(Boolean).join("."), "");
-}
-const cache = /* @__PURE__ */ new WeakMap();
-function getGroqFromPath(schema, node, path) {
-  const cached = cache.get(node)?.get(path);
-  if (cached) return cached;
-  const possiblePaths = Array.from(
-    new Set(resolveAllPaths(schema, node, path.split(".")).map(printPath))
-  );
-  if (!possiblePaths.length)
-    return console.warn(`Could not resolve path \`${path}\` from schema type \`${node.name}\`.`), "null";
-  const result = possiblePaths.length === 1 ? possiblePaths[0] : `coalesce(${possiblePaths.join(",")})`;
-  return cache.has(node) || cache.set(node, /* @__PURE__ */ new Map()), cache.get(node).set(path, result), result;
-}
-function resolveAllPaths(schema, schemaType, path) {
-  const [name, ...rest] = path;
-  if (name?.startsWith("_"))
-    return [
-      [
-        { type: "attribute", name },
-        ...rest.map(
-          (next) => /\d+/.test(next) ? { type: "element", index: parseInt(next, 10) } : { type: "attribute", name: next }
-        )
-      ]
-    ];
-  if (name) {
-    if (isReferenceType(schemaType))
-      return schemaType.to.flatMap(
-        (referenceType) => resolveAllPaths(schema, referenceType, path).map((nextPath) => [
-          { type: "deref" },
-          ...nextPath
-        ])
-      );
-    if (schemaType.jsonType === "object") {
-      const fieldType = schemaType.fields.find((field) => field.name === name)?.type;
-      return fieldType ? resolveAllPaths(schema, fieldType, rest).map((nextPath) => [
-        { type: "attribute", name },
-        ...nextPath
-      ]) : [];
-    } else if (schemaType.jsonType === "array") {
-      const index = parseInt(name, 10);
-      return schemaType.of.flatMap(
-        (itemType) => resolveAllPaths(schema, itemType, rest).map((nextPath) => [
-          { type: "element", index },
-          ...nextPath
-        ])
-      );
-    } else
-      return [];
-  } else return [[]];
+const TITLE_CANDIDATES = ["title", "name", "label", "heading", "header", "caption"], SUBTITLE_CANDIDATES = ["description", "subtitle", ...TITLE_CANDIDATES];
+function getPreviewProjection() {
+  return `{
+    // Get all potential title fields
+    "titleCandidates": {
+      ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
+      `)}
+    },
+    // Get all potential subtitle fields
+    "subtitleCandidates": {
+      ${SUBTITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(`,
+      `)}
+    },
+    "media": coalesce(
+      select(
+        defined(asset) => {"type": "image-asset", "_ref": asset._ref},
+        defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
+        defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
+        null
+      )
+    ),
+    _type,
+    _id,
+    _updatedAt
+  }`;
 }
 const PREVIEW_TAG = "preview", STABLE_EMPTY_PREVIEW = { results: null, isPending: !1 }, STABLE_ERROR_PREVIEW = {
   results: {
@@ -1047,13 +1011,6 @@ const PREVIEW_TAG = "preview", STABLE_EMPTY_PREVIEW = { results: null, isPending
   },
   isPending: !1
 };
-function defaultPrepare(value) {
-  let title, subtitle;
-  return "title" in value && typeof value.title == "string" && (title = value.title), "subtitle" in value && typeof value.subtitle == "string" && (subtitle = value.subtitle), { title: title ?? "Untitled", subtitle };
-}
-function hasImageAsset(value) {
-  return typeof value == "object" && value !== null && "asset" in value && typeof value.asset == "object" && typeof value.asset?._ref == "string";
-}
 function assetIdToUrl(assetId, projectId, dataset) {
   const pattern = /^image-(?<assetName>[A-Za-z0-9]+)-(?<dimensions>\d+x\d+)-(?<format>[a-z]+)$/, match = assetId.match(pattern);
   if (!match?.groups)
@@ -1063,53 +1020,43 @@ function assetIdToUrl(assetId, projectId, dataset) {
   const { assetName, dimensions, format } = match.groups;
   return `https://cdn.sanity.io/images/${projectId}/${dataset}/${assetName}-${dimensions}.${format}`;
 }
+function hasImageRef(value) {
+  return isObject(value) && "_ref" in value && typeof value._ref == "string";
+}
 function normalizeMedia(media, projectId, dataset) {
-  return !media || !hasImageAsset(media) ? null : { type: "image-asset", url: assetIdToUrl(media.asset._ref, projectId, dataset) };
+  return !media || !hasImageRef(media) ? null : {
+    type: "image-asset",
+    _ref: media._ref,
+    url: assetIdToUrl(media._ref, projectId, dataset)
+  };
 }
-function preparePreviewForSchemaType({
-  projectId,
-  dataset,
-  schema,
-  schemaTypeName,
-  selectResult
-}) {
-  const schemaType = schema.get(schemaTypeName);
-  if (!schemaType)
-    throw new Error(
-      `Could not find schema type \`${schemaTypeName}\` in schema \`${schema.name}\`.`
-    );
-  const prepare = schemaType.preview?.prepare ?? defaultPrepare;
-  try {
-    const result = prepare(selectResult);
-    return { ...result, media: normalizeMedia(result.media, projectId, dataset) };
-  } catch (e3) {
-    const message = typeof e3 == "object" && e3 && "message" in e3 && typeof e3.message == "string" ? e3.message : "Unknown error.";
-    throw new Error(`Failed to prepare preview: ${message}`, { cause: e3 });
-  }
+function findFirstDefined(fieldsToSearch, candidates, exclude) {
+  if (candidates)
+    for (const field of fieldsToSearch) {
+      const value = candidates[field];
+      if (typeof value == "string" && value.trim() !== "" && value !== exclude)
+        return value;
+    }
 }
 function processPreviewQuery({
   projectId,
   dataset,
-  schema,
   ids,
-  documentTypes,
   results
 }) {
   const resultMap = results.reduce((acc, next) => (acc[next._id] = next, acc), {});
   return Object.fromEntries(
     Array.from(ids).map((id) => {
-      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId], documentType = documentTypes[publishedId];
-      if (!documentType) return [id, STABLE_EMPTY_PREVIEW];
-      const selectResult = draftResult?.select ?? publishedResult?.select;
-      if (!selectResult) return [id, STABLE_EMPTY_PREVIEW];
+      const publishedId = getPublishedId(id), draftId = getDraftId(id), draftResult = resultMap[draftId], publishedResult = resultMap[publishedId];
+      if (!draftResult && !publishedResult) return [id, STABLE_EMPTY_PREVIEW];
       try {
-        const preview = preparePreviewForSchemaType({
-          projectId,
-          dataset,
-          schema,
-          schemaTypeName: documentType,
-          selectResult
-        }), status = {
+        const result = draftResult || publishedResult;
+        if (!result) return [id, STABLE_EMPTY_PREVIEW];
+        const title = findFirstDefined(TITLE_CANDIDATES, result.titleCandidates), subtitle = findFirstDefined(SUBTITLE_CANDIDATES, result.subtitleCandidates, title), preview = {
+          title: String(title || `${result._type}: ${result._id}`),
+          subtitle: subtitle || void 0,
+          media: normalizeMedia(result.media, projectId, dataset)
+        }, status = {
           ...draftResult?._updatedAt && { lastEditedDraftAt: draftResult._updatedAt },
           ...publishedResult?._updatedAt && { lastEditedPublishedAt: publishedResult._updatedAt }
         };
@@ -1120,37 +1067,18 @@ function processPreviewQuery({
     })
   );
 }
-function createPreviewQuery(documentIds, documentTypes, schema) {
-  const documentIdsByDocumentType = Array.from(documentIds).reduce(
-    (acc, id) => {
-      const documentType = documentTypes[id];
-      if (!documentType) return acc;
-      const ids = acc[documentType] ?? /* @__PURE__ */ new Set();
-      return ids.add(id), acc[documentType] = ids, acc;
-    },
-    {}
-  ), projections = Object.keys(documentIdsByDocumentType).map((documentType) => {
-    const projection = getProjectionForSchemaType(schema, documentType), projectionHash = hashString(projection);
-    return { documentType, projection, projectionHash };
-  }).reduce((acc, { documentType, projection, projectionHash }) => {
-    const obj = acc[projectionHash] ?? { documentTypes: /* @__PURE__ */ new Set(), projection };
-    return obj.documentTypes.add(documentType), acc[projectionHash] = obj, acc;
-  }, {}), query = `[${Object.entries(projections).map(([projectionHash, { projection }]) => `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"select":${projection}}`).join(",")}]`, params = Object.fromEntries(
-    Object.entries(projections).map(([projectionHash, value]) => {
-      const idsInProjection = Array.from(
-        Array.from(value.documentTypes).map((documentType) => documentIdsByDocumentType[documentType] ?? /* @__PURE__ */ new Set()).reduce((acc, next) => {
-          for (const i2 of next) acc.add(i2);
-          return acc;
-        }, /* @__PURE__ */ new Set())
-      ).flatMap((id) => [getPublishedId(id), getDraftId(id)]);
-      return [`__ids_${projectionHash}`, Array.from(idsInProjection)];
-    })
-  );
-  return { query, params };
+function createPreviewQuery(documentIds) {
+  const allIds = Array.from(documentIds).flatMap((id) => [getPublishedId(id), getDraftId(id)]), projection = getPreviewProjection(), queryHash = hashString(projection);
+  return {
+    query: `*[_id in $__ids_${queryHash}]${projection}`,
+    params: {
+      [`__ids_${queryHash}`]: allIds
+    }
+  };
 }
 const BATCH_DEBOUNCE_TIME$1 = 50, subscribeToStateAndFetchBatches$1 = createInternalAction(
   ({ state, instance }) => function() {
-    const client$ = getClientState(instance, { apiVersion: "vX" }).observable, schema$ = getSchemaState(instance).observable, documentTypes$ = state.observable.pipe(
+    const client$ = getClientState(instance, { apiVersion: "vX" }).observable, documentTypes$ = state.observable.pipe(
       map((i2) => i2.documentTypes),
       distinctUntilChanged()
     ), lastLiveEventId$ = state.observable.pipe(
@@ -1177,27 +1105,25 @@ const BATCH_DEBOUNCE_TIME$1 = 50, subscribeToStateAndFetchBatches$1 = createInte
       withLatestFrom(documentTypes$),
       map(([[, ids], documentTypes]) => ({ ids, documentTypes }))
     );
-    return combineLatest([newSubscriberIds$, lastLiveEventId$, client$, schema$]).pipe(
-      switchMap$1(([{ ids, documentTypes }, lastLiveEventId, client, schema]) => {
+    return combineLatest([newSubscriberIds$, lastLiveEventId$, client$]).pipe(
+      switchMap$1(([{ ids }, lastLiveEventId, client]) => {
         if (!ids.size) return EMPTY;
-        const { query, params } = createPreviewQuery(ids, documentTypes, schema);
+        const { query, params } = createPreviewQuery(ids);
         return client.observable.fetch(query, params, {
           filterResponse: !1,
           returnQuery: !1,
           perspective: "drafts",
           tag: PREVIEW_TAG,
           lastLiveEventId
-        }).pipe(map((response) => ({ ...response, ids, schema, documentTypes })));
+        }).pipe(map((response) => ({ ...response, ids })));
       }),
-      map(({ ids, result, syncTags, documentTypes, schema }) => ({
+      map(({ ids, result, syncTags }) => ({
         syncTags,
         values: processPreviewQuery({
           projectId: instance.identity.projectId,
           dataset: instance.identity.dataset,
           ids,
-          documentTypes,
-          results: result,
-          schema
+          results: result
         })
       }))
     ).subscribe({
@@ -4916,7 +4842,7 @@ const _resolveQuery = createAction(queryStore, ({ state }) => function(query, {
   );
   return firstValueFrom(race([resolved$, aborted$]));
 });
-var version = "0.0.0-alpha.16";
+var version = "0.0.0-alpha.17";
 const CORE_SDK_VERSION = getEnv("PKG_VERSION") || `${version}-development`;
 export {
   AuthStateType,