@consilioweb/payload-support 6.0.0 → 6.0.1

package/dist/utils/db.js

@@ -0,0 +1,20 @@
+function dbFind(payload, slug, options = {}) {
+  return payload.find({ collection: slug, ...options });
+}
+function dbFindByID(payload, slug, options) {
+  return payload.findByID({ collection: slug, ...options });
+}
+function dbCreate(payload, slug, options) {
+  return payload.create({ collection: slug, ...options });
+}
+function dbUpdate(payload, slug, options) {
+  return payload.update({ collection: slug, ...options });
+}
+function dbCount(payload, slug, options = {}) {
+  return payload.count({ collection: slug, ...options });
+}
+function dbDelete(payload, slug, options) {
+  return payload.delete({ collection: slug, ...options });
+}
+
+export { dbCount, dbCreate, dbDelete, dbFind, dbFindByID, dbUpdate };

package/dist/utils/readSettings.js

@@ -0,0 +1,150 @@
+import { dbFind } from './db.js';
+import { DEFAULT_TICKETING_FEATURES, projectAutoClose, normalizeFeatures } from './features.js';
+
+const SUPPORT_SETTINGS_PREF_KEY = "support-settings";
+const PREF_KEY = SUPPORT_SETTINGS_PREF_KEY;
+const USER_PREFS_KEY_PREFIX = "support-user-prefs";
+const LEGACY_ROUND_ROBIN_KEY = "support-round-robin";
+const SUPPORT_STAFF_SLUG_CONFIG_KEY = "supportStaffCollection";
+function resolveStaffPrefSlug(payload, staffSlug) {
+  if (staffSlug) return staffSlug;
+  const config = payload.config;
+  const registered = config?.custom?.[SUPPORT_STAFF_SLUG_CONFIG_KEY];
+  if (typeof registered === "string" && registered) return registered;
+  return config?.admin?.user || "users";
+}
+const DEFAULT_SETTINGS = {
+  email: { fromAddress: "", fromName: "Support", replyToAddress: "" },
+  ai: { provider: "anthropic", model: "claude-haiku-4-5-20251001", enableSentiment: true, enableSynthesis: true, enableSuggestion: true, enableRewrite: true },
+  sla: { firstResponseMinutes: 120, resolutionMinutes: 1440, businessHoursOnly: true, escalationEmail: "" },
+  autoClose: { enabled: true, daysBeforeClose: 7, reminderDaysBefore: 2 },
+  features: { ...DEFAULT_TICKETING_FEATURES }
+};
+const DEFAULT_USER_PREFS = {
+  locale: "fr",
+  signature: ""
+};
+const settingsCache = /* @__PURE__ */ new Map();
+const SETTINGS_TTL_MS = 6e4;
+const SETTINGS_CACHE_MAX = 8;
+const warnedForeignSettingsRow = /* @__PURE__ */ new Set();
+function invalidateSupportSettingsCache() {
+  settingsCache.clear();
+  warnedForeignSettingsRow.clear();
+}
+function mergeSupportSettings(stored, base = DEFAULT_SETTINGS) {
+  const autoClose = { ...base.autoClose, ...stored?.autoClose };
+  return {
+    email: { ...base.email, ...stored?.email },
+    ai: { ...base.ai, ...stored?.ai },
+    sla: { ...base.sla, ...stored?.sla },
+    autoClose,
+    // `autoClose` / `autoCloseDays` are projections of the block above, so they
+    // are recomputed here rather than trusted from whatever was persisted.
+    features: projectAutoClose(
+      normalizeFeatures({ ...base.features, ...stored?.features }),
+      autoClose
+    )
+  };
+}
+async function readSupportSettingsState(payload, staffSlug) {
+  const staff = resolveStaffPrefSlug(payload, staffSlug);
+  const cached = settingsCache.get(staff);
+  if (cached && Date.now() - cached.ts < SETTINGS_TTL_MS) {
+    return cached.value;
+  }
+  let value = {
+    settings: mergeSupportSettings(null),
+    featuresConfigured: false
+  };
+  try {
+    const prefs = await dbFind(payload, "payload-preferences", {
+      // Sibling keys are AND-ed by Payload. The `user.relationTo` clause is the
+      // security boundary: without it any authenticated principal can plant a
+      // `support-settings` row and own the plugin's server settings.
+      where: { key: { equals: PREF_KEY }, "user.relationTo": { equals: staff } },
+      // The upsert is scoped per admin user, so several rows can share the key.
+      // Sorting makes "last write wins" deterministic instead of arbitrary.
+      sort: "-updatedAt",
+      limit: 1,
+      depth: 0,
+      overrideAccess: true
+    });
+    if (prefs.docs.length > 0) {
+      const stored = prefs.docs[0].value;
+      const featuresConfigured = !!stored.features && typeof stored.features === "object";
+      const settings = mergeSupportSettings(stored);
+      if (!featuresConfigured) {
+        settings.features.roundRobin = await readLegacyRoundRobin(payload, staff);
+      }
+      value = { settings, featuresConfigured };
+    } else {
+      await warnOnForeignSettingsRow(payload, staff);
+    }
+  } catch {
+  }
+  if (settingsCache.size >= SETTINGS_CACHE_MAX && !settingsCache.has(staff)) settingsCache.clear();
+  settingsCache.set(staff, { value, ts: Date.now() });
+  return value;
+}
+async function warnOnForeignSettingsRow(payload, staff) {
+  if (warnedForeignSettingsRow.has(staff)) return;
+  try {
+    const any = await dbFind(payload, "payload-preferences", {
+      where: { key: { equals: PREF_KEY } },
+      limit: 1,
+      depth: 0,
+      overrideAccess: true
+    });
+    if (any.docs.length === 0) return;
+    if (warnedForeignSettingsRow.size >= SETTINGS_CACHE_MAX) warnedForeignSettingsRow.clear();
+    warnedForeignSettingsRow.add(staff);
+    console.warn(
+      `[support] A "${PREF_KEY}" preference row exists but none is owned by the "${staff}" collection: the plugin is running on its DEFAULT settings. Either the staff auth collection differs from \`admin.user\`, or the row was written by a principal that is not staff \u2014 in which case it is ignored on purpose.`
+    );
+  } catch {
+  }
+}
+async function readSupportSettings(payload, staffSlug) {
+  return (await readSupportSettingsState(payload, staffSlug)).settings;
+}
+async function readLegacyRoundRobin(payload, staff) {
+  try {
+    const prefs = await dbFind(payload, "payload-preferences", {
+      where: { key: { equals: LEGACY_ROUND_ROBIN_KEY }, "user.relationTo": { equals: staff } },
+      limit: 1,
+      depth: 0,
+      overrideAccess: true
+    });
+    if (prefs.docs.length > 0) {
+      return prefs.docs[0].value?.enabled === true;
+    }
+  } catch {
+  }
+  return DEFAULT_TICKETING_FEATURES.roundRobin;
+}
+async function readUserPrefs(payload, userId, staffSlug) {
+  try {
+    const key = `${USER_PREFS_KEY_PREFIX}-${userId}`;
+    const prefs = await dbFind(payload, "payload-preferences", {
+      where: {
+        key: { equals: key },
+        "user.relationTo": { equals: resolveStaffPrefSlug(payload, staffSlug) }
+      },
+      limit: 1,
+      depth: 0,
+      overrideAccess: true
+    });
+    if (prefs.docs.length > 0) {
+      const stored = prefs.docs[0].value;
+      return {
+        locale: stored.locale || DEFAULT_USER_PREFS.locale,
+        signature: stored.signature ?? DEFAULT_USER_PREFS.signature
+      };
+    }
+  } catch {
+  }
+  return { ...DEFAULT_USER_PREFS };
+}
+
+export { DEFAULT_SETTINGS, DEFAULT_USER_PREFS, SUPPORT_SETTINGS_PREF_KEY, SUPPORT_STAFF_SLUG_CONFIG_KEY, invalidateSupportSettingsCache, mergeSupportSettings, readSupportSettings, readSupportSettingsState, readUserPrefs, resolveStaffPrefSlug };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@consilioweb/payload-support",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "description": "Payload CMS plugin — professional support & ticketing system with AI, SLA, time tracking, live chat, and more",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -52,7 +52,8 @@
     "scripts/uninstall.mjs",
     "scripts/uninstall-data.mjs",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "scripts"
   ],
   "keywords": [
     "payload",
@@ -137,7 +138,7 @@
     }
   },
   "scripts": {
-    "build": "tsup && tsc -p tsconfig.types.json && node scripts/copy-subpath-types.mjs",
+    "build": "tsup && tsc -p tsconfig.types.json && node scripts/copy-subpath-types.mjs && node scripts/verify-dist-imports.mjs",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",

package/scripts/copy-subpath-types.mjs

@@ -0,0 +1,103 @@
+/**
+ * Copies the declarations emitted by `tsc -p tsconfig.types.json` into dist/,
+ * then rewrites their relative import specifiers so they carry an explicit
+ * `.js` extension.
+ *
+ * Why a separate pass: the `bundle: false` tsup entry that emits dist/views/**
+ * and dist/components/** cannot generate declarations — turning `dts: true` on
+ * for ~100 entries makes rollup-plugin-dts run for well over ten minutes without
+ * finishing. Without them, `dist/views.d.ts` re-exports 13 views from paths that
+ * carry no declaration (TS7016 under noImplicitAny) and the publicly documented
+ * `./components/TicketConversation` subpath has no types at all.
+ *
+ * Why the extension rewrite: the sources are compiled with
+ * `moduleResolution: bundler`, so both tsc and tsup emit extensionless relative
+ * specifiers (`from './client'`, `from '../../utils/features'`). A consumer on
+ * `moduleResolution: node16 | nodenext` — the recommended setting for an ESM
+ * package — then gets `TS2835: Relative import paths need explicit file
+ * extensions`, and with the default `skipLibCheck: true` that error is swallowed
+ * and every export silently degrades to `any`. tsup's `onSuccess` already does
+ * this for the emitted `.js`; this does the same for the `.d.ts` (the copied ones
+ * *and* the `dist/views.d.ts` barrel produced by tsup's dts pass).
+ *
+ * `utils` is copied too: the emitted view declarations reference
+ * `../../utils/features`, whose JS is already emitted by the same tsup pass.
+ */
+import { cpSync, existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+
+const OUT = '.types-out'
+const SUBPATHS = ['views', 'components', 'utils']
+
+if (!existsSync(OUT)) {
+  console.error(`[build] "${OUT}" is missing — run \`tsc -p tsconfig.types.json\` before this script.`)
+  process.exit(1)
+}
+
+for (const dir of SUBPATHS) {
+  const from = `${OUT}/${dir}`
+  if (existsSync(from)) cpSync(from, `dist/${dir}`, { recursive: true })
+}
+
+rmSync(OUT, { recursive: true, force: true })
+console.log('✓ Copied subpath declarations into dist/')
+
+// ─── Explicit .js extensions on relative specifiers ──────────────────────────
+
+const HAS_EXTENSION = /\.(js|jsx|mjs|cjs|css|scss|json)$/
+const RELATIVE_SPECIFIER = /((?:from|import)\s*['"])(\.\.?\/[^'"]+?)(['"])/g
+
+const errors = []
+
+/** Resolve an extensionless specifier against the emitted declarations. */
+function withExtension(fromFile, specifier) {
+  const base = resolve(dirname(fromFile), specifier)
+  if (existsSync(`${base}.d.ts`)) return `${specifier}.js`
+  if (existsSync(join(base, 'index.d.ts'))) return `${specifier}/index.js`
+  return null
+}
+
+function rewrite(file) {
+  const content = readFileSync(file, 'utf-8')
+  const fixed = content.replace(RELATIVE_SPECIFIER, (match, prefix, specifier, suffix) => {
+    if (HAS_EXTENSION.test(specifier)) return match
+    const resolved = withExtension(file, specifier)
+    if (!resolved) {
+      errors.push(`${file}: cannot resolve "${specifier}" to an emitted declaration`)
+      return match
+    }
+    return `${prefix}${resolved}${suffix}`
+  })
+  if (fixed !== content) writeFileSync(file, fixed)
+}
+
+function walkDts(dir) {
+  if (!existsSync(dir)) return
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry)
+    if (statSync(path).isDirectory()) {
+      walkDts(path)
+      continue
+    }
+    if (path.endsWith('.d.ts')) rewrite(path)
+  }
+}
+
+// The `./views` barrel is emitted by tsup's dts pass, not by the tsc pass above,
+// but it has the exact same extensionless specifiers — and it is the entry point
+// consumers actually import, so it matters most.
+const VIEWS_BARREL = 'dist/views.d.ts'
+if (!existsSync(VIEWS_BARREL)) {
+  console.error(`[build] "${VIEWS_BARREL}" is missing — did the tsup views barrel entry run?`)
+  process.exit(1)
+}
+rewrite(VIEWS_BARREL)
+for (const dir of SUBPATHS) walkDts(`dist/${dir}`)
+
+if (errors.length > 0) {
+  console.error('[build] unresolved relative specifiers in emitted declarations:')
+  for (const error of errors) console.error(`  - ${error}`)
+  process.exit(1)
+}
+
+console.log('✓ Added explicit .js extensions to relative specifiers in dist/**/*.d.ts')

package/scripts/verify-dist-imports.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Every relative import in `dist/` must resolve to a file that is actually there.
+ *
+ * This catches one specific, silent failure mode of a multi-pass tsup build.
+ * The `bundle: false` pass preserves the source tree and rewrites nothing, so a
+ * relative import survives into the emitted file. If the target module is not
+ * itself in that pass's `entry` list, it is never emitted as a standalone file —
+ * it only exists inlined inside the bundled `dist/index.js`. The import then
+ * points at nothing.
+ *
+ * Nothing in the normal toolchain sees it. `tsc` type-checks the SOURCE tree,
+ * where the module exists. Vitest imports from `src/`, same thing. The build
+ * itself succeeds — tsup has no reason to object. The failure surfaces only when
+ * the HOST application's bundler resolves the published package, which is to say
+ * after publication, in someone else's build.
+ *
+ * `import type` is invisible here on purpose: TypeScript erases it, so it leaves
+ * no trace in the emitted file and cannot break anything. Only value imports do.
+ * That is why the defect hid for two releases in this package — every other
+ * importer of the same module used `import type`.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+
+const DIST = resolve(process.cwd(), 'dist')
+
+if (!existsSync(DIST)) {
+  console.error('verify-dist-imports: dist/ is missing — run the build first.')
+  process.exit(1)
+}
+
+/** Every emitted JavaScript file, at any depth. */
+function walk(dir) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(dir, entry.name)
+    if (entry.isDirectory()) return walk(path)
+    return /\.(js|cjs|mjs)$/.test(entry.name) ? [path] : []
+  })
+}
+
+/**
+ * Relative specifiers only. Bare specifiers are the consumer's dependency
+ * problem, not ours, and `node:` builtins always resolve.
+ */
+const SPECIFIER =
+  /(?:^|[\s;{(])(?:import|export)\s+(?:[^'"]*?\sfrom\s+)?['"](\.[^'"]+)['"]|require\(\s*['"](\.[^'"]+)['"]\s*\)|import\(\s*['"](\.[^'"]+)['"]\s*\)/g
+
+/** Resolve the way Node and a bundler would: as written, then the usual suffixes. */
+function resolves(fromFile, specifier) {
+  const base = resolve(dirname(fromFile), specifier)
+  const candidates = [
+    base,
+    `${base}.js`, `${base}.cjs`, `${base}.mjs`,
+    join(base, 'index.js'), join(base, 'index.cjs'), join(base, 'index.mjs'),
+  ]
+  return candidates.some((c) => existsSync(c) && statSync(c).isFile())
+}
+
+const broken = []
+for (const file of walk(DIST)) {
+  const source = readFileSync(file, 'utf8')
+  for (const match of source.matchAll(SPECIFIER)) {
+    const specifier = match[1] || match[2] || match[3]
+    if (!specifier || resolves(file, specifier)) continue
+    broken.push({ file: file.replace(`${process.cwd()}/`, ''), specifier })
+  }
+}
+
+if (broken.length === 0) {
+  console.log('verify-dist-imports: every relative import in dist/ resolves.')
+  process.exit(0)
+}
+
+console.error(`verify-dist-imports: ${broken.length} unresolved relative import(s) in dist/.\n`)
+for (const { file, specifier } of broken) {
+  console.error(`  ${file}\n    imports '${specifier}' — not emitted`)
+}
+console.error(
+  '\nThe target is almost certainly missing from the `entry` list of the\n' +
+    '`bundle: false` pass in tsup.config.ts. Add it there, or move the value\n' +
+    'being imported into a module that pass already emits.',
+)
+process.exit(1)