sanity-plugin-transifex 1.1.2 → 2.0.2

package/dist/helpers.d.ts

@@ -1,5 +0,0 @@
-import { SanityDocument } from '@sanity/types';
-export declare const findLatestDraft: (documentId: string) => any;
-export declare const findDocumentAtRevision: (documentId: string, rev: string) => Promise<any>;
-export declare const documentLevelPatch: (documentId: string, translatedFields: SanityDocument, localeId: string) => Promise<void>;
-export declare const fieldLevelPatch: (documentId: string, translatedFields: SanityDocument, localeId: string) => Promise<void>;

package/src/helpers.ts

@@ -1,114 +0,0 @@
-import { SanityDocument } from '@sanity/types'
-import sanityClient from 'part:@sanity/base/client'
-import { BaseDocumentMerger } from 'sanity-naive-html-serializer'
-
-const client = sanityClient.withConfig({ apiVersion: '2021-03-25' })
-
-//document fetch
-export const findLatestDraft = (documentId: string) => {
-  //eliminates i18n versions
-  const query = `*[_id == $id || _id == $draftId]`
-  const params = { id: `${documentId}`, draftId: `drafts.${documentId}` }
-  return client
-    .fetch(query, params)
-    .then(
-      (docs: SanityDocument[]) =>
-        docs.find(doc => doc._id.includes('draft')) ?? docs[0]
-    )
-}
-
-//revision fetch
-export const findDocumentAtRevision = async (
-  documentId: string,
-  rev: string
-) => {
-  const dataset = client.config().dataset
-  let baseUrl = `/data/history/${dataset}/documents/${documentId}?revision=${rev}`
-  let url = client.getUrl(baseUrl)
-  let revisionDoc = await fetch(url, { credentials: 'include' })
-    .then(req => req.json())
-    .then(req => req.documents[0])
-  /* endpoint will silently give you incorrect doc
-   * if you don't request draft and the rev belongs to a draft, so check
-   */
-  if (!revisionDoc || revisionDoc._rev !== rev) {
-    baseUrl = `/data/history/${dataset}/documents/drafts.${documentId}?revision=${rev}`
-    url = client.getUrl(baseUrl)
-    revisionDoc = await fetch(url, { credentials: 'include' })
-      .then(req => req.json())
-      .then(req => req.documents[0])
-  }
-  return revisionDoc
-}
-
-//document-level patch
-export const documentLevelPatch = async (
-  documentId: string,
-  translatedFields: SanityDocument,
-  localeId: string
-) => {
-  let baseDoc: SanityDocument
-  if (translatedFields._rev) {
-    baseDoc = await findDocumentAtRevision(documentId, translatedFields._rev)
-  } else {
-    baseDoc = await findLatestDraft(documentId)
-  }
-
-  const merged = BaseDocumentMerger.documentLevelMerge(
-    translatedFields,
-    baseDoc
-  )
-  const targetId = `i18n.${documentId}.${localeId}`
-  const i18nDoc = await findLatestDraft(targetId)
-
-  if (i18nDoc) {
-    const cleanedMerge: Record<string, any> = {}
-    //don't overwrite any existing values on the i18n doc
-    Object.entries(merged).forEach(([key, value]) => {
-      if (
-        Object.keys(translatedFields).includes(key) &&
-        !['_id', '_rev', '_updatedAt'].includes(key)
-      ) {
-        cleanedMerge[key] = value
-      }
-    })
-    client
-      .transaction()
-      //@ts-ignore
-      .patch(i18nDoc._id, p => p.set(cleanedMerge))
-      .commit()
-  } else {
-    merged._id = `drafts.${targetId}`
-    //account for legacy implementations of i18n plugin lang
-    if (baseDoc._lang) {
-      merged._lang = localeId
-    } else if (baseDoc.__i18n_lang) {
-      merged.__i18n_lang = localeId
-    }
-    client.create(merged)
-  }
-}
-
-//field level patch
-export const fieldLevelPatch = async (
-  documentId: string,
-  translatedFields: SanityDocument,
-  localeId: string
-) => {
-  let baseDoc: SanityDocument
-  if (translatedFields._rev) {
-    baseDoc = await findDocumentAtRevision(documentId, translatedFields._rev)
-  } else {
-    baseDoc = await findLatestDraft(documentId)
-  }
-  const merged = BaseDocumentMerger.fieldLevelMerge(
-    translatedFields,
-    baseDoc,
-    localeId,
-    'en'
-  )
-  client
-    .patch(baseDoc._id)
-    .set(merged)
-    .commit()
-}

package/src/transifexAdapter.ts

@@ -1,230 +0,0 @@
-import { Adapter, Secrets } from 'sanity-translations-tab'
-
-const baseTransifexUrl = 'https://rest.api.transifex.com'
-const getHeaders = (secrets: Secrets | null) => ({
-  Authorization: `Bearer ${secrets?.token}`,
-  'Content-Type': 'application/vnd.api+json',
-})
-const projOrgSlug = (secrets: Secrets | null) =>
-  `o:${secrets?.organization}:p:${secrets?.project}`
-
-const getLocales = async (secrets: Secrets | null) => {
-  if (secrets) {
-    return fetch(
-      `${baseTransifexUrl}/projects/${projOrgSlug(secrets)}/languages`,
-      { headers: getHeaders(secrets) }
-    )
-      .then(res => res.json())
-      .then(res =>
-        res.data.map((lang: Record<string, any>) => ({
-          enabled: true,
-          description: lang.attributes.name,
-          localeId: lang.attributes.code,
-        }))
-      )
-  } else {
-    return []
-  }
-}
-
-const getTranslationTask = async (
-  documentId: string,
-  secrets: Secrets | null
-) => {
-  if (!documentId || !secrets) {
-    return {
-      taskId: documentId,
-      documentId: documentId,
-      locales: [],
-    }
-  }
-  const projectFilter = `filter[project]=${projOrgSlug(secrets)}`
-  const resourceFilter = `filter[resource]=${projOrgSlug(
-    secrets
-  )}:r:${documentId}`
-  const task = await fetch(
-    `${baseTransifexUrl}/resource_language_stats?${projectFilter}&${resourceFilter}`,
-    { headers: getHeaders(secrets) }
-  )
-    .then(res => {
-      if (res.ok) {
-        return res.json()
-      }
-      //normal -- just means that this task doesn't exist yet.
-      else if (res.status === 404) {
-        return { data: [] }
-      } else {
-        throw Error(
-          `Failed to retrieve tasks from Transifex. Status: ${res.status}`
-        )
-      }
-    })
-    .then(res => ({
-      taskId: `${projOrgSlug(secrets)}:r:${documentId}`,
-      documentId: documentId,
-      locales: res.data.map((locale: Record<string, any>) => ({
-        localeId: locale.relationships.language.data.id.split(':')[1],
-        progress: Math.floor(
-          100 *
-            (locale.attributes.reviewed_strings /
-              parseFloat(locale.attributes.total_strings))
-        ),
-      })),
-    }))
-
-  const locales = await getLocales(secrets)
-  const localeIds = locales.map((l: Record<string, any>) => l.localeId)
-  const validLocales = task.locales.filter((locale: Record<string, any>) =>
-    localeIds.find((id: string) => id === locale.localeId)
-  )
-  task.locales = validLocales
-
-  return task
-}
-
-const createResource = async (
-  doc: Record<string, any>,
-  documentId: string,
-  secrets: Secrets | null
-) => {
-  const resourceCreateBody = {
-    data: {
-      attributes: {
-        accept_translations: true,
-        name: doc.name,
-        slug: documentId,
-      },
-      relationships: {
-        i18n_format: {
-          data: {
-            id: 'HTML_FRAGMENT',
-            type: 'i18n_formats',
-          },
-        },
-        project: {
-          data: {
-            id: projOrgSlug(secrets),
-            type: 'projects',
-          },
-        },
-      },
-      type: 'resources',
-    },
-  }
-
-  return fetch(`${baseTransifexUrl}/resources`, {
-    headers: getHeaders(secrets),
-    method: 'POST',
-    body: JSON.stringify(resourceCreateBody),
-  })
-    .then(res => res.json())
-    .then(res => res.data.id)
-}
-
-const createTask = async (
-  documentId: string,
-  document: Record<string, any>,
-  //unfortunately Transifex doesn't let you specify locales on creating a task
-  //@ts-ignore
-  localeIds: string[],
-  secrets: Secrets | null
-) => {
-  let resourceId = await fetch(
-    `${baseTransifexUrl}/resources/${projOrgSlug(secrets)}:r:${documentId}`,
-    { headers: getHeaders(secrets) }
-  )
-    .then(res => res.json())
-    .then(res => (res.data ? res.data.id : null))
-
-  if (!resourceId) {
-    resourceId = await createResource(document, documentId, secrets)
-  }
-
-  const resourceUploadUrl = `${baseTransifexUrl}/resource_strings_async_uploads`
-  const resourceUploadBody = {
-    data: {
-      attributes: {
-        content: document.content,
-        content_encoding: 'text',
-      },
-      relationships: {
-        resource: {
-          data: {
-            id: resourceId,
-            type: 'resources',
-          },
-        },
-      },
-      type: 'resource_strings_async_uploads',
-    },
-  }
-
-  return fetch(resourceUploadUrl, {
-    method: 'POST',
-    body: JSON.stringify(resourceUploadBody),
-    headers: getHeaders(secrets),
-  }).then(() => getTranslationTask(documentId, secrets))
-}
-
-const getTranslation = async (
-  taskId: string,
-  localeId: string,
-  secrets: Secrets | null
-) => {
-  const resourceDownloadBody = {
-    data: {
-      attributes: {
-        content_encoding: 'text',
-      },
-      relationships: {
-        language: {
-          data: {
-            id: `l:${localeId}`,
-            type: 'languages',
-          },
-        },
-        resource: {
-          data: {
-            id: taskId,
-            type: 'resources',
-          },
-        },
-      },
-      type: 'resource_translations_async_downloads',
-    },
-  }
-
-  const resourceDownloadUrl = `${baseTransifexUrl}/resource_translations_async_downloads`
-  const translationDownloadId = await fetch(resourceDownloadUrl, {
-    headers: getHeaders(secrets),
-    method: 'POST',
-    body: JSON.stringify(resourceDownloadBody),
-  })
-    .then(res => res.json())
-    .then(res => res.data.id)
-
-  return new Promise(resolve => {
-    setTimeout(function() {
-      fetch(`${resourceDownloadUrl}/${translationDownloadId}`, {
-        headers: getHeaders(secrets),
-      }).then(res => {
-        if (res.redirected) {
-          return resolve(handleFileDownload(res.url))
-        } else {
-          return res.json()
-        }
-      })
-    }, 3000)
-  })
-}
-
-const handleFileDownload = async (url: string) => {
-  return fetch(url).then(res => res.text())
-}
-
-export const TransifexAdapter: Adapter = {
-  getLocales,
-  getTranslationTask,
-  createTask,
-  getTranslation,
-}