@sanity/document-internationalization 1.0.0 → 1.0.2

package/src/structure/index.tsx

@@ -0,0 +1,120 @@
+import {EarthGlobeIcon} from '@sanity/icons'
+import {Schema, SchemaType} from 'sanity'
+import {DocumentListBuilder, ListItemBuilder, StructureBuilder} from 'sanity/desk'
+import {applyConfig} from '../utils'
+import {I18nDelimiter, I18nPrefix, IdStructure, UiMessages} from '../constants'
+import {Ti18nConfig} from '../types'
+import {createMaintenanceTabComponent} from './components/MaintenanceTab'
+
+export interface StructureConfig {
+  S: StructureBuilder
+  config: Ti18nConfig
+  schema: Schema & {
+    i18n?: Ti18nConfig
+  }
+}
+
+const hasIcon = (schemaType?: SchemaType | string): boolean => {
+  if (!schemaType || typeof schemaType === 'string') {
+    return false
+  }
+  return Boolean(schemaType.icon)
+}
+
+export const getDefaultDocumentNode = (S: StructureBuilder) => {
+  return S.document()
+}
+
+export const getDocumentTypes = (props: StructureConfig) => {
+  const {S, schema} = props
+  const listItemsWithouti18n: ListItemBuilder[] = []
+  const listItemsWithi18n = S.documentTypeListItems().filter((l) => {
+    let schemaType = l.getSchemaType()
+    schemaType = typeof schemaType === 'string' ? schema.get(schemaType) : schemaType
+
+    const hasi18n = schemaType && (schemaType as unknown as {i18n: boolean}).i18n
+    if (!hasi18n) listItemsWithouti18n.push(l)
+    return hasi18n
+  })
+  return {
+    withoutI18n: listItemsWithouti18n,
+    withI18n: listItemsWithi18n,
+  }
+}
+
+export const getMaintenanceTabComponent = (props: StructureConfig) => {
+  const {S} = props
+  const MaintenanceTab = createMaintenanceTabComponent(props)
+  return S.component(MaintenanceTab)
+    .title(UiMessages.translationsMaintenance.title)
+    .id(`__i18n_translations_maintenance_tab`)
+}
+
+export const getMaintenanceListItem = (props: StructureConfig) => {
+  const {S} = props
+  return S.listItem()
+    .id(`__i18n_translations_maintenance_tab`)
+    .title(UiMessages.translationsMaintenance.title)
+    .icon(EarthGlobeIcon)
+    .child(getMaintenanceTabComponent(props))
+}
+
+export const getFilteredDocumentTypeListItems = (props: StructureConfig) => {
+  const {S, config: pluginConfig, schema} = props
+  const config = applyConfig(
+    pluginConfig,
+    typeof schema.i18n === 'object' ? schema.i18n : undefined
+  )
+  const types = getDocumentTypes(props)
+  const filterFns = {
+    [IdStructure.SUBPATH]: (list: ListItemBuilder, doc: DocumentListBuilder) =>
+      doc.filter('!(_id in path($path)) && !(_id in path($drafts)) && _type == $type').params({
+        path: `${I18nPrefix}.**`,
+        drafts: `drafts.${I18nPrefix}.**`,
+        type: list.getId(),
+      }),
+    [IdStructure.DELIMITER]: (list: ListItemBuilder, doc: DocumentListBuilder) =>
+      doc.filter('!(_id match $id) && _type == $type').params({
+        id: `*${I18nDelimiter}*`,
+        type: list.getId(),
+      }),
+  }
+
+  const items = [
+    ...types.withoutI18n,
+    ...types.withI18n.map((l) => {
+      const schemaType = l.getSchemaType()
+      const schemaTypeName = typeof schemaType === 'string' ? schemaType : schemaType?.name
+
+      return l.child(
+        filterFns[config.idStructure](
+          l,
+          S.documentList()
+            .id(l.getId() || '')
+            .title(l.getTitle() || '')
+            .schemaType(schemaTypeName ?? '')
+            .menuItems([...(schemaTypeName ? S.orderingMenuItemsForType(schemaTypeName) : [])])
+        )
+      )
+    }),
+  ]
+
+  if (config.withTranslationsMaintenance) {
+    items.splice(0, 0, getMaintenanceListItem(props))
+  }
+
+  return items.map((item) => item.serialize())
+}
+
+export function getDocumentList(props: StructureConfig) {
+  const {S} = props
+  const types = getDocumentTypes(props)
+  if (types.withI18n.length === 0) return S.defaults()
+
+  const items = getFilteredDocumentTypeListItems(props)
+  return S.list()
+    .id('__root__')
+    .title('Content')
+    .items(items)
+    .showIcons(items.some((item) => hasIcon(item.schemaType)))
+}

package/src/structure/utils/fixBaseDocumentRefs.ts

@@ -0,0 +1,30 @@
+import type {SanityDocument, SanityClient, Transaction} from '@sanity/client'
+import {ReferenceBehavior} from '../../constants'
+import {ApplyConfigResult, createSanityReference, getBaseIdFromId} from '../../utils'
+
+export const fixBaseDocumentRefs = (
+  sanityClient: SanityClient,
+  config: ApplyConfigResult,
+  translatedDocuments: SanityDocument[]
+): Transaction => {
+  const transaction = sanityClient.transaction()
+
+  if (config.referenceBehavior !== ReferenceBehavior.DISABLED) {
+    const baseRefFieldName = config.fieldNames.baseReference
+    translatedDocuments.forEach((d) => {
+      if (!d[baseRefFieldName]) {
+        const baseId = getBaseIdFromId(d._id)
+        transaction.patch(d._id, {
+          set: {
+            [baseRefFieldName]: createSanityReference(
+              baseId,
+              config.referenceBehavior === ReferenceBehavior.WEAK
+            ),
+          },
+        })
+      }
+    })
+  }
+
+  return transaction
+}

package/src/structure/utils/fixBaseLanguageMismatch.ts

@@ -0,0 +1,21 @@
+import type {SanityDocument, SanityClient, Transaction} from '@sanity/client'
+import {ApplyConfigResult, getBaseLanguage, getLanguagesFromOption} from '../../utils'
+
+export const fixBaseLanguageMismatch = async (
+  sanityClient: SanityClient,
+  config: ApplyConfigResult,
+  basedocuments: SanityDocument[]
+): Promise<Transaction> => {
+  const languages = await getLanguagesFromOption(sanityClient, config, config.languages)
+  const baseLanguage = getBaseLanguage(languages, config.base)
+  const langFieldName = config.fieldNames.lang
+  const transaction = sanityClient.transaction()
+  basedocuments.forEach((doc) => {
+    if (doc[langFieldName] !== baseLanguage?.id) {
+      transaction.patch(doc._id, {
+        set: {[langFieldName]: baseLanguage?.id}, // eslint-disable-line
+      })
+    }
+  })
+  return transaction
+}

package/src/structure/utils/fixIdStructureMismatchDocuments.ts

@@ -0,0 +1,72 @@
+import type {SanityDocument, Transaction} from '@sanity/client'
+import chunk from 'just-split'
+import {SanityClient} from '@sanity/client'
+import {ReferenceBehavior} from '../../constants'
+import {
+  ApplyConfigResult,
+  buildDocId,
+  createSanityReference,
+  getBaseIdFromId,
+  getLanguageFromDocument,
+} from '../../utils'
+
+export const fixIdStructureMismatchDocuments = (
+  sanityClient: SanityClient,
+  config: ApplyConfigResult,
+  schema: string,
+  documents: SanityDocument[]
+): Transaction[] => {
+  const refsFieldName = config.fieldNames.references
+
+  // remove old refs
+  const existingBaseDocumentIds = new Set(documents.map((d) => getBaseIdFromId(d._id)))
+  const removeOldRefsTransaction = sanityClient.transaction()
+  existingBaseDocumentIds.forEach((id) => {
+    removeOldRefsTransaction.patch(id, {
+      set: {[refsFieldName]: []},
+    })
+  })
+
+  // create new document ids
+  const newDocumentTransactions = chunk(
+    documents.filter((d) => d._id !== getBaseIdFromId(d._id)),
+    100
+  ).map((documentsChunk) => {
+    const transaction = sanityClient.transaction()
+    documentsChunk.forEach((d) => {
+      const baseId = getBaseIdFromId(d._id)
+      const lang = getLanguageFromDocument(d, config)
+      if (lang) {
+        const newId = buildDocId(config, baseId, lang)
+        transaction.createIfNotExists({
+          ...d,
+          _id: newId,
+          _type: schema,
+        })
+        transaction.delete(d._id)
+
+        // patch base document with updated refs
+        if (config.referenceBehavior !== ReferenceBehavior.DISABLED) {
+          transaction.patch(baseId, {setIfMissing: {[refsFieldName]: []}})
+          transaction.patch(baseId, {
+            insert: {
+              after: `${refsFieldName}[-1]`,
+              items: [
+                {
+                  _key: lang,
+                  ...createSanityReference(
+                    newId,
+                    config.referenceBehavior === ReferenceBehavior.WEAK
+                  ),
+                },
+              ],
+            },
+          })
+        }
+      }
+    })
+    return transaction
+  })
+
+  return [removeOldRefsTransaction, ...newDocumentTransactions]
+}

package/src/structure/utils/fixLanguageFields.ts

@@ -0,0 +1,32 @@
+import type {SanityClient, SanityDocument, Transaction} from '@sanity/client'
+import type {Schema} from 'sanity'
+import {Ti18nSchema} from '../../types'
+import {ApplyConfigResult, getLanguageFromId} from '../../utils'
+
+export const fixLanguageFields = (
+  sanityClient: SanityClient,
+  config: ApplyConfigResult,
+  schemaRegistry: Schema,
+  documents: SanityDocument[]
+): Transaction => {
+  const langFieldName = config.fieldNames?.lang
+  const transaction = sanityClient.transaction()
+
+  documents.forEach((d) => {
+    const schemaObject = schemaRegistry.get(d._type) as Ti18nSchema
+    const base =
+      (typeof schemaObject.i18n === 'object' ? schemaObject.i18n.base : undefined) || config.base
+    if (!d[langFieldName]) {
+      // @README keep the language from ID behavior
+      // because in this case we expect the language field not to be available
+      const language = getLanguageFromId(d._id) || base
+      transaction.patch(d._id, {
+        set: {
+          [langFieldName]: language,
+        },
+      })
+    }
+  })
+
+  return transaction
+}

package/src/structure/utils/fixOrphanedDocuments.ts

@@ -0,0 +1,22 @@
+import type {SanityClient, SanityDocument, Transaction} from '@sanity/client'
+import type {Reference} from 'sanity'
+import {ApplyConfigResult} from '../../utils'
+
+export const fixOrphanedDocuments = (
+  sanityClient: SanityClient,
+  config: ApplyConfigResult,
+  basedocuments: SanityDocument[],
+  translatedDocuments: SanityDocument[]
+): Transaction => {
+  const transaction = sanityClient.transaction()
+  translatedDocuments.forEach((d) => {
+    const base = basedocuments.find(
+      (doc) =>
+        (Array.isArray(d?.[config.fieldNames.references]) &&
+          d?.[config.fieldNames.references]?.some((ref: Reference) => ref._ref === d._id)) ||
+        doc._id === d?.[config.fieldNames.baseReference]?._ref
+    )
+    if (!base) transaction.delete(d._id)
+  })
+  return transaction
+}

package/src/structure/utils/fixTranslationRefs.ts

@@ -0,0 +1,50 @@
+import chunk from 'lodash/chunk'
+import compact from 'lodash/compact'
+import {SanityClient, Transaction, SanityDocument} from '@sanity/client'
+import type {Reference} from 'sanity'
+import {ReferenceBehavior} from '../../constants'
+import {
+  ApplyConfigResult,
+  createSanityReference,
+  getBaseIdFromId,
+  getLanguageFromDocument,
+} from '../../utils'
+
+export const fixTranslationRefs = (
+  sanityClient: SanityClient,
+  config: ApplyConfigResult,
+  baseDocuments: SanityDocument[],
+  translatedDocuments: SanityDocument[]
+  // eslint-disable-next-line max-params
+): Transaction[] => {
+  const refsFieldName = config.fieldNames.references
+  const transactions = chunk(baseDocuments, 50).map((documentsChunk) => {
+    const transaction = sanityClient.transaction()
+    documentsChunk.forEach((d) => {
+      let translatedRefs: Reference[] = []
+      const relevantTranslations = translatedDocuments.filter(
+        (dx) => getBaseIdFromId(dx._id) === d._id
+      )
+      if (config.referenceBehavior !== ReferenceBehavior.DISABLED) {
+        translatedRefs = compact(
+          relevantTranslations.map((doc) => {
+            const lang = getLanguageFromDocument(doc, config)
+            if (!lang) return null
+            return {
+              _key: lang,
+              ...createSanityReference(
+                doc._id,
+                config.referenceBehavior === ReferenceBehavior.WEAK
+              ),
+            }
+          }, {})
+        )
+      }
+      transaction.patch(d._id, {
+        set: {[refsFieldName]: translatedRefs},
+      })
+    })
+    return transaction
+  })
+  return transactions
+}

package/src/structure/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './fixIdStructureMismatchDocuments'
+export * from './fixLanguageFields'
+export * from './fixTranslationRefs'
+export * from './fixOrphanedDocuments'
+export * from './fixBaseLanguageMismatch'
+export * from './fixBaseDocumentRefs'

package/src/types/IEditState.ts

@@ -0,0 +1,6 @@
+import type {SanityDocument} from '@sanity/client'
+
+export interface IEditState<T extends Record<string, any> = Record<string, any>> {
+  draft?: SanityDocument<T>
+  published?: SanityDocument<T>
+}

package/src/types/IExtendedLanguageObject.ts

@@ -0,0 +1,6 @@
+import type {ILanguageObject} from './ILanguageObject'
+
+export interface IExtendedLanguageObject extends ILanguageObject {
+  isCurrentLanguage?: boolean
+  isBase?: boolean
+}

package/src/types/ILanguageObject.ts

@@ -0,0 +1,4 @@
+export interface ILanguageObject {
+  id: string
+  title: string
+}

package/src/types/ILanguageQuery.ts

@@ -0,0 +1,13 @@
+export interface ILanguageQuery {
+  query: string
+  value:
+    | string
+    | {
+        id: string
+        title: string
+      }
+    | {
+        name: string
+        title: string
+      }
+}

package/src/types/IResolverProps.ts

@@ -0,0 +1,10 @@
+import {SanityDocument} from '@sanity/client'
+
+export interface IResolverProps<T extends Record<string, any> = Record<string, any>> {
+  id: string
+  type: string
+  liveEdit: boolean
+  draft?: SanityDocument<T>
+  published?: SanityDocument<T>
+  onComplete?: () => void
+}

package/src/types/ITranslationRef.ts

@@ -0,0 +1,6 @@
+export interface ITranslationRef {
+  _key: string
+  _type: 'reference'
+  _ref: string
+  _weak?: boolean
+}

package/src/types/IType.ts

@@ -0,0 +1,40 @@
+import {TLanguagesOption} from './TLanguagesOption'
+import {ObjectSchemaTypeWithOptions} from 'sanity'
+export interface IField {
+  name: string
+  type: IType
+  readOnly?: boolean
+}
+
+export interface IFieldSet {
+  name: string
+  title: string
+  description: string
+  single: boolean
+  options: ObjectSchemaTypeWithOptions['options']
+  field: IField
+  fields: IField[]
+}
+
+export interface IType {
+  name: string
+  title: string
+  description: string
+  hidden?: boolean
+  level: number
+  type: string
+  jsonType: string
+  fields: IField[]
+  fieldsets: IFieldSet[]
+  options: ObjectSchemaTypeWithOptions['options'] & {
+    base?: string
+    i18n?: boolean
+    languages?: TLanguagesOption
+    css?: (classNames: Record<string, string>) => string
+    messages?: {
+      loading?: string
+      missingTranslations?: string
+    }
+    [key: string]: any
+  }
+}

package/src/types/IUseDocumentOperationResult.ts

@@ -0,0 +1,11 @@
+type ExecutablAction = {
+  disabled?: string
+  execute: (...args: any[]) => void
+}
+
+export interface IUseDocumentOperationResult {
+  patch: ExecutablAction
+  publish: ExecutablAction
+  duplicate: ExecutablAction
+  delete: ExecutablAction
+}

package/src/types/TFieldNamesConfig.ts

@@ -0,0 +1,5 @@
+export type TFieldNamesConfig = {
+  lang?: string
+  references?: string
+  baseReference?: string
+}

package/src/types/TLanguage.ts

@@ -0,0 +1,3 @@
+import {ILanguageObject} from './ILanguageObject'
+
+export type Tlanguage = string | ILanguageObject

package/src/types/TLanguagesOption.ts

@@ -0,0 +1,4 @@
+import {ILanguageQuery} from './ILanguageQuery'
+import {ILanguageObject} from './ILanguageObject'
+
+export type TLanguagesOption = (string | ILanguageObject)[] | ILanguageQuery

package/src/types/TSchema.ts

@@ -0,0 +1,6 @@
+export type TSchema<T = any> = T & {
+  name: string
+  title: string
+  icon?: any
+  fields: any[]
+}

package/src/types/Ti18nConfig.ts

@@ -0,0 +1,33 @@
+import {SanityDocument, SchemaType} from 'sanity'
+import type {ComponentType, FC} from 'react'
+import {IdStructure, ReferenceBehavior} from '../constants'
+import {TLanguagesOption} from './TLanguagesOption'
+import {TFieldNamesConfig} from './TFieldNamesConfig'
+import {ILanguageObject} from './ILanguageObject'
+
+export type Ti18nConfig = {
+  base?: string
+  languages?: TLanguagesOption
+  idStructure?: IdStructure
+  referenceBehavior?: ReferenceBehavior
+  fieldNames?: TFieldNamesConfig
+  withTranslationsMaintenance?: boolean
+  languagesLoader?: (
+    languages: ILanguageObject[],
+    doc: SanityDocument | undefined
+  ) => Promise<ILanguageObject[]> | ILanguageObject[]
+  shouldReload?: (doc: SanityDocument | undefined | null) => boolean
+  fallbackLanguageSelect?: FC<{
+    schemaType?: SchemaType & {
+      i18n?: boolean | Ti18nConfig
+    }
+  }>
+  customFlagComponents?: Record<
+    string,
+    ComponentType<{
+      className?: string
+      code?: string
+      langCulture?: string
+    }>
+  >
+}

package/src/types/Ti18nDocument.ts

@@ -0,0 +1,14 @@
+import type {SanityDocument} from '@sanity/client'
+
+// @README these types are not per-se accurate as field names can
+// be manually configured and are not always these defaults
+export type Ti18nDocument<D extends Record<string, any> = Record<string, any>> =
+  SanityDocument<D> & {
+    __i18n_lang?: string
+    __i18n_refs?: {
+      _key: string
+      _type: 'reference'
+      _ref: string
+      _weak: boolean
+    }[]
+  }

package/src/types/Ti18nSchema.ts

@@ -0,0 +1,13 @@
+import {SchemaType} from 'sanity'
+import {Ti18nConfig} from './Ti18nConfig'
+
+declare module '@sanity/types' {
+  // makes i18n property allowed on document when using defineTyp/defineField/defineArrayMember
+  export interface DocumentDefinition {
+    i18n?: boolean | Ti18nConfig
+  }
+}
+
+export type Ti18nSchema = SchemaType & {
+  i18n: boolean | Ti18nConfig
+}

package/src/types/index.ts

@@ -0,0 +1,15 @@
+export * from './ILanguageObject'
+export * from './IExtendedLanguageObject'
+export * from './ILanguageQuery'
+export * from './IType'
+export * from './TLanguage'
+export * from './IResolverProps'
+export * from './TLanguagesOption'
+export * from './TSchema'
+export * from './Ti18nSchema'
+export * from './Ti18nConfig'
+export * from './Ti18nDocument'
+export * from './TFieldNamesConfig'
+export * from './IUseDocumentOperationResult'
+export * from './ITranslationRef'
+export * from './IEditState'

package/src/utils/applyConfig.ts

@@ -0,0 +1,43 @@
+import {IdStructure, ReferenceBehavior} from '../constants'
+import type {Ti18nConfig} from '../types'
+
+type ApplyConfigOptionalKeys =
+  | 'shouldReload'
+  | 'languagesLoader'
+  | 'fallbackLanguageSelect'
+  | 'customFlagComponents'
+export type ApplyConfigResult = Omit<
+  Required<{
+    [K in keyof Ti18nConfig]: Required<Ti18nConfig[K]>
+  }>,
+  ApplyConfigOptionalKeys
+> &
+  Pick<Ti18nConfig, ApplyConfigOptionalKeys>
+
+export function applyConfig(
+  baseConfig?: Ti18nConfig,
+  incomingConfig?: Ti18nConfig | null
+): ApplyConfigResult {
+  return {
+    base: incomingConfig?.base || baseConfig?.base || '',
+    languages: incomingConfig?.languages || baseConfig?.languages || [],
+    idStructure: baseConfig?.idStructure || IdStructure.DELIMITER,
+    referenceBehavior: baseConfig?.referenceBehavior || ReferenceBehavior.STRONG,
+    withTranslationsMaintenance: baseConfig?.withTranslationsMaintenance === true,
+    shouldReload: baseConfig?.shouldReload,
+    languagesLoader: baseConfig?.languagesLoader,
+    fallbackLanguageSelect: baseConfig?.fallbackLanguageSelect,
+    customFlagComponents: baseConfig?.customFlagComponents,
+    fieldNames: {
+      lang: incomingConfig?.fieldNames?.lang || baseConfig?.fieldNames?.lang || '__i18n_lang',
+      references:
+        incomingConfig?.fieldNames?.references ||
+        baseConfig?.fieldNames?.references ||
+        '__i18n_refs',
+      baseReference:
+        incomingConfig?.fieldNames?.baseReference ||
+        baseConfig?.fieldNames?.baseReference ||
+        '__i18n_base',
+    },
+  }
+}

package/src/utils/baseToTop.ts

@@ -0,0 +1,5 @@
+import type {IExtendedLanguageObject} from '../types'
+
+export const baseToTop = (a: IExtendedLanguageObject, b: IExtendedLanguageObject): number => {
+  return Number(a.isBase ?? 0) - Number(b.isBase ?? 0)
+}

package/src/utils/buildDocId.ts

@@ -0,0 +1,8 @@
+import {Ti18nConfig} from '../types'
+import {I18nDelimiter, I18nPrefix, IdStructure} from '../constants'
+
+export const buildDocId = (pluginConfig: Ti18nConfig, id: string, lang?: string | null): string => {
+  if (pluginConfig.idStructure === IdStructure.DELIMITER)
+    return `${id}${I18nDelimiter}${lang || '*'}`
+  return `${I18nPrefix}.${id}.${lang || '*'}`
+}

package/src/utils/createSanityReference.ts

@@ -0,0 +1,11 @@
+import type {Reference} from 'sanity'
+
+type Ref = Omit<Reference, '_type'> & {_type: 'reference'}
+
+export function createSanityReference(id: string, weak = false): Ref {
+  return {
+    _type: 'reference' as const,
+    _ref: id.replace(`drafts.`, ``),
+    ...(weak === true ? {_weak: true} : {}),
+  }
+}

package/src/utils/getBaseIdFromId.ts

@@ -0,0 +1,20 @@
+import {I18nPrefix, I18nDelimiter} from '../constants'
+
+/*  Generic to support both string -> string & string? -> string? */
+export const getBaseIdFromId = <T extends string | undefined>(id?: T): T => {
+  if (!id) {
+    return undefined as T
+  }
+  const nonDraftId = id.replace(/^drafts\./, '')
+
+  // subpath
+  const rx = new RegExp(`${I18nPrefix}\\.([^.]+)\\.[^.]+`)
+  const match = nonDraftId.match(rx)
+  if (match && match.length === 2) return match[1] as T
+
+  // delimiter
+  const split = nonDraftId.split(I18nDelimiter)
+  if (split.length > 0) return split[0] as T
+
+  return nonDraftId as T
+}