@notifiles/sdk 1.5.3 → 1.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@notifiles/sdk",
   "type": "module",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "",
   "author": {
     "name": "adoucoure",

package/src/lib/cloudLibrary/minio/upload.js

@@ -4,7 +4,7 @@ export default async ({
   sourceUrl,
   filename,
   auth,
-  // contentType = 'image/png'
+  contentType = null,
 }) => {
 
   try {
@@ -33,7 +33,7 @@ export default async ({
     }
 
     const metaData = {
-      // 'Content-Type': contentType,
+      ...(contentType ? { 'Content-Type': contentType } : {}),
     }
 
     const minioResult = await new Promise((resolve, reject) => {

package/src/template/index.js

@@ -2,3 +2,4 @@ export * as build from './build/index.js'
 export * as sync from './sync/index.js'
 export * as update from './update/index.js'
 export { default as create } from './new/index.js'
+export * as locales from './locales/index.js'

package/src/template/locales/build.js

@@ -0,0 +1,75 @@
+// The locales index of an app's templates (`locales.json`, published at the root of each cloud by every update):
+// which locales each template exists in, the app's default locale, and each language's default locale. A sender
+// reads it to pick the best locale a template has for a reader (en-gb -> en-us) instead of probing for files.
+//
+// A template's locales are what its version step builds: the keys of its i18n.json plus the default locale
+// (template/format/entry.js). Every template is listed, the ones an update skipped as unchanged included, so the
+// index always describes the whole app.
+//
+// Each language's default comes from the app (`settings.languageDefaults`, e.g. `{ en: 'en-us', pt: 'pt-br' }`).
+// Without one for a language, it is the app's default locale when that is of the language, else the language's only
+// locale; a language with several locales and no default named is left out, for the sender to choose.
+
+export const LOCALES_INDEX_FILE_NAME = 'locales.json'
+export const LOCALES_INDEX_VERSION = 1
+
+export const normalizedLocaleOf = (locale) =>
+  locale ? String(locale).trim().toLowerCase().replace(/_/g, '-') : null
+
+const languageOf = (locale) => normalizedLocaleOf(locale)?.split('-')[0] || null
+
+/** The locales one template is built in, normalised, sorted. */
+export const localesOfTheEntry = ({ entry, defaultLocale }) => {
+  const locales = [...Object.keys(entry?.i18n || {}), defaultLocale]
+    .map(normalizedLocaleOf)
+    .filter(Boolean)
+  return [...new Set(locales)].sort()
+}
+
+const languageDefaultsOf = ({ allLocales, defaultLocale, languageDefaults = {} }) => {
+  const named = Object.fromEntries(
+    Object.entries(languageDefaults || {})
+      .map(([language, locale]) => [String(language).toLowerCase(), normalizedLocaleOf(locale)])
+      .filter(([, locale]) => Boolean(locale))
+  )
+  const byLanguage = {}
+  for (const locale of allLocales) {
+    const language = languageOf(locale)
+    byLanguage[language] = [...(byLanguage[language] || []), locale]
+  }
+  const derived = {}
+  for (const [language, locales] of Object.entries(byLanguage)) {
+    if (named[language]) {
+      continue
+    }
+    if (languageOf(defaultLocale) === language) {
+      derived[language] = defaultLocale
+    } else if (locales.length === 1) {
+      derived[language] = locales[0]
+    }
+  }
+  return Object.fromEntries(Object.entries({ ...derived, ...named }).sort(([a], [b]) => a.localeCompare(b)))
+}
+
+/** The index for `entries` (as getEntries reads them) and the app's settings. */
+export const buildLocalesIndex = ({ entries = [], settings = {}, now = new Date() }) => {
+  const defaultLocale = normalizedLocaleOf(settings.defaultLocale) || 'en-us'
+  const templates = {}
+  for (const entry of entries) {
+    if (!entry?.slug) {
+      continue
+    }
+    templates[String(entry.slug).toLowerCase()] = localesOfTheEntry({ entry, defaultLocale })
+  }
+  const allLocales = [...new Set(Object.values(templates).flat())].sort()
+  return {
+    version: LOCALES_INDEX_VERSION,
+    generatedAt: now.toISOString(),
+    defaultLocale,
+    languageDefaults: languageDefaultsOf({ allLocales, defaultLocale, languageDefaults: settings.languageDefaults }),
+    locales: allLocales,
+    templates: Object.fromEntries(Object.entries(templates).sort(([a], [b]) => a.localeCompare(b))),
+  }
+}
+
+export default buildLocalesIndex

package/src/template/locales/build.test.js

@@ -0,0 +1,42 @@
+import { buildLocalesIndex, localesOfTheEntry } from './build.js'
+
+const now = new Date('2026-10-22T08:00:00.000Z')
+
+const entries = [
+  { slug: 'automationemail', i18n: { 'en-us': {}, 'fr-fr': {}, 'es-es': {} } },
+  { slug: 'Welcome', i18n: { 'fr_FR': {}, 'pt-br': {}, 'pt-pt': {} } },
+  { slug: 'bare', i18n: {} },
+]
+
+describe('buildLocalesIndex', () => {
+  it('lists every template with the locales it is built in, the default locale included', () => {
+    const index = buildLocalesIndex({ entries, settings: { defaultLocale: 'en-us' }, now })
+    expect(index.templates).toEqual({
+      automationemail: ['en-us', 'es-es', 'fr-fr'],
+      bare: ['en-us'],
+      welcome: ['en-us', 'fr-fr', 'pt-br', 'pt-pt'],
+    })
+    expect(index.defaultLocale).toBe('en-us')
+    expect(index.version).toBe(1)
+    expect(index.generatedAt).toBe('2026-10-22T08:00:00.000Z')
+  })
+
+  it('names a default per language: the app default for its language, a lone locale for the others', () => {
+    const index = buildLocalesIndex({ entries, settings: { defaultLocale: 'en-us' }, now })
+    expect(index.languageDefaults).toEqual({ en: 'en-us', es: 'es-es', fr: 'fr-fr' })
+  })
+
+  it('takes the app\'s named defaults over the derived ones, for ambiguous languages too', () => {
+    const index = buildLocalesIndex({
+      entries,
+      settings: { defaultLocale: 'en_US', languageDefaults: { pt: 'pt_BR', fr: 'fr-fr' } },
+      now,
+    })
+    expect(index.languageDefaults).toEqual({ en: 'en-us', es: 'es-es', fr: 'fr-fr', pt: 'pt-br' })
+    expect(index.locales).toEqual(['en-us', 'es-es', 'fr-fr', 'pt-br', 'pt-pt'])
+  })
+
+  it('normalises locales', () => {
+    expect(localesOfTheEntry({ entry: { i18n: { 'EN_gb': {} } }, defaultLocale: 'en-us' })).toEqual(['en-gb', 'en-us'])
+  })
+})

package/src/template/locales/index.js

@@ -0,0 +1,2 @@
+export { default as build, LOCALES_INDEX_FILE_NAME, LOCALES_INDEX_VERSION } from './build.js'
+export { default as publish } from './publish.js'

package/src/template/locales/publish.js

@@ -0,0 +1,44 @@
+import fs from 'fs'
+import os from 'os'
+import fsPath from 'path'
+import { buildLocalesIndex, LOCALES_INDEX_FILE_NAME } from './build.js'
+
+/**
+ * Builds the locales index of `entries` and uploads it as `locales.json` at the root of every cloud in
+ * `settings.clouds`. Answers `{ index, uploads: [{ id, url }] }`; a cloud that refuses the upload is reported with a
+ * null url and never fails the update (the templates themselves are already synced).
+ */
+export const publishLocalesIndex = async ({ entries, settings, now = new Date() }) => {
+  const index = buildLocalesIndex({ entries, settings, now })
+  const folder = await fs.promises.mkdtemp(fsPath.join(os.tmpdir(), 'notifiles-locales-'))
+  const sourceUrl = fsPath.join(folder, LOCALES_INDEX_FILE_NAME)
+  await fs.promises.writeFile(sourceUrl, JSON.stringify(index, null, 2))
+
+  const uploads = []
+  try {
+    for (const cloud of settings.clouds || []) {
+      const cloudLibrary = settings.cloudLibrary?.({ id: cloud.id })
+      if (!cloudLibrary?.upload) {
+        uploads.push({ id: cloud.id, url: null })
+        continue
+      }
+      const result = await cloudLibrary.upload({
+        sourceUrl,
+        filename: LOCALES_INDEX_FILE_NAME,
+        auth: cloud.auth,
+        contentType: 'application/json',
+      })
+      uploads.push({ id: cloud.id, url: result?.url || null })
+    }
+  } finally {
+    await fs.promises.rm(folder, { recursive: true, force: true })
+  }
+  for (const upload of uploads) {
+    console.log(upload.url
+      ? `[notifiles] Locales index published: ${upload.url}`
+      : `[notifiles] Locales index not published to ${upload.id}`)
+  }
+  return { index, uploads }
+}
+
+export default publishLocalesIndex

package/src/template/update/path.js

@@ -13,6 +13,7 @@ import {
   updateTemplateHashCache
 } from './lib/cache.js'
 import runWithConcurrency from '../../lib/async/runWithConcurrency.js'
+import publishLocalesIndex from '../locales/publish.js'
 
 const DEFAULT_CONCURRENCY = 10
 
@@ -67,5 +68,10 @@ export default async ({
     }
   })
 
+  // The index of every template's locales, unchanged ones included, so a sender picks a locale a template has.
+  if (!settings.dryRun && settings.isLocalesIndexPublished !== false) {
+    await publishLocalesIndex({ entries, settings })
+  }
+
   return true
 }