@dappermountain/payload-plugin-achievements 0.1.0

package/dist/seed/index.js

@@ -0,0 +1,375 @@
+import { ENGINE_EVENT_TYPES, ENGINE_METRICS } from '../catalog';
+import { collectionOf } from '../collections/helpers';
+import { normalizeRuleGroup } from '../services/achievement/evaluateRules';
+function localizedParts(value) {
+    if (value == null)
+        return {};
+    if (typeof value === 'string')
+        return { en: value };
+    const out = {};
+    for (const [locale, text] of Object.entries(value)) {
+        if (typeof text === 'string' && text.length > 0)
+            out[locale] = text;
+    }
+    return out;
+}
+async function writeLocalizedFields(payload, args) {
+    const nameParts = localizedParts(args.fields.name);
+    const descriptionParts = localizedParts(args.fields.description);
+    const base = args.baseData ?? {};
+    const locales = new Set([...Object.keys(nameParts), ...Object.keys(descriptionParts)]);
+    // Default locale first so other locales can fall back cleanly.
+    const orderedLocales = ['en', ...[...locales].filter((locale) => locale !== 'en')];
+    for (const locale of orderedLocales) {
+        const name = nameParts[locale];
+        const description = descriptionParts[locale];
+        if (name == null && description == null && locale !== 'en')
+            continue;
+        await payload.update({
+            collection: args.collection,
+            id: args.id,
+            data: {
+                ...(locale === 'en' ? base : {}),
+                ...(name != null ? { name } : {}),
+                ...(description != null ? { description } : {}),
+            },
+            locale: locale,
+            overrideAccess: true,
+        });
+    }
+}
+async function findIdBySlug(payload, key, slug) {
+    const result = await payload.find({
+        collection: collectionOf(key),
+        depth: 0,
+        limit: 1,
+        overrideAccess: true,
+        where: { slug: { equals: slug } },
+    });
+    const id = result.docs[0]?.id;
+    return typeof id === 'string' ? id : null;
+}
+async function upsertCatalog(payload, key, row) {
+    const existing = await findIdBySlug(payload, key, row.slug);
+    const nameParts = localizedParts(row.name);
+    const data = {
+        name: nameParts.en ?? row.slug,
+        slug: row.slug,
+        scope: row.scope,
+        system: row.system ?? false,
+        ...(key === 'eventTypes'
+            ? {
+                requiresActor: row.requiresActor ?? false,
+                requiresMetric: row.requiresMetric ?? false,
+            }
+            : {}),
+    };
+    let id = existing;
+    if (existing) {
+        await payload.update({
+            collection: collectionOf(key),
+            id: existing,
+            data,
+            locale: 'en',
+            overrideAccess: true,
+        });
+    }
+    else {
+        const created = await payload.create({
+            collection: collectionOf(key),
+            data,
+            locale: 'en',
+            overrideAccess: true,
+        });
+        id = String(created.id);
+    }
+    if (id) {
+        const extraLocales = Object.entries(nameParts).filter(([locale]) => locale !== 'en');
+        for (const [locale, name] of extraLocales) {
+            await payload.update({
+                collection: collectionOf(key),
+                id,
+                data: { name },
+                locale: locale,
+                overrideAccess: true,
+            });
+        }
+    }
+}
+async function resolveRuleNode(payload, rule) {
+    const next = { ...rule };
+    if (next.type === 'group' && Array.isArray(next.rules)) {
+        next.rules = await Promise.all(next.rules.map((child) => resolveRuleNode(payload, child)));
+        return next;
+    }
+    if (next.type === 'tier-at-least' && !next.tier && typeof next.tierSlug === 'string') {
+        const id = await findIdBySlug(payload, 'tiers', next.tierSlug);
+        if (id) {
+            next.tier = id;
+            delete next.tierSlug;
+        }
+    }
+    if (next.type === 'achievement-complete' &&
+        !next.achievement &&
+        typeof next.achievementSlug === 'string') {
+        const id = await findIdBySlug(payload, 'achievements', next.achievementSlug);
+        if (id) {
+            next.achievement = id;
+            delete next.achievementSlug;
+        }
+    }
+    if (next.type === 'event-count') {
+        const slug = typeof next.eventTypeSlug === 'string'
+            ? next.eventTypeSlug
+            : typeof next.eventType === 'string'
+                ? next.eventType
+                : '';
+        if (slug) {
+            const id = await findIdBySlug(payload, 'eventTypes', slug);
+            if (id) {
+                next.eventType = id;
+                delete next.eventTypeSlug;
+            }
+        }
+    }
+    if (next.type === 'metric-minimum') {
+        const slug = typeof next.metricSlug === 'string' ? next.metricSlug : typeof next.metric === 'string' ? next.metric : '';
+        if (slug) {
+            const id = await findIdBySlug(payload, 'metrics', slug);
+            if (id) {
+                next.metric = id;
+                delete next.metricSlug;
+            }
+        }
+    }
+    return next;
+}
+async function resolveRuleGroup(payload, input) {
+    const group = normalizeRuleGroup(input);
+    return {
+        combinator: group.combinator,
+        rules: await Promise.all(group.rules.map((rule) => resolveRuleNode(payload, rule))),
+    };
+}
+/** Upsert engine event types + metrics (`system: true`). English (default locale) only. */
+export async function seedAchievementCatalog(payload, scope) {
+    await renameEngineEventTypeSlug(payload, 'metric.change', 'metric.delta', 'Metric delta');
+    for (const row of ENGINE_EVENT_TYPES) {
+        await upsertCatalog(payload, 'eventTypes', {
+            ...row,
+            name: row.name,
+            scope,
+            system: true,
+        });
+    }
+    for (const row of ENGINE_METRICS) {
+        await upsertCatalog(payload, 'metrics', {
+            ...row,
+            name: row.name,
+            scope,
+            system: true,
+        });
+    }
+}
+/** Rename a leftover engine event-type slug in place (preserves relationship ids). */
+async function renameEngineEventTypeSlug(payload, fromSlug, toSlug, name) {
+    const fromId = await findIdBySlug(payload, 'eventTypes', fromSlug);
+    if (!fromId)
+        return;
+    if (await findIdBySlug(payload, 'eventTypes', toSlug))
+        return;
+    const nameParts = localizedParts(name);
+    await payload.update({
+        collection: collectionOf('eventTypes'),
+        id: fromId,
+        data: { slug: toSlug, name: nameParts.en ?? toSlug, system: true },
+        locale: 'en',
+        overrideAccess: true,
+    });
+    for (const [locale, text] of Object.entries(nameParts)) {
+        if (locale === 'en' || !text)
+            continue;
+        await payload.update({
+            collection: collectionOf('eventTypes'),
+            id: fromId,
+            data: { name: text },
+            locale: locale,
+            overrideAccess: true,
+        });
+    }
+}
+/**
+ * Idempotent upsert of achievement definitions by slug. Host supplies its own catalog and ladder data.
+ */
+export async function seedAchievements(payload, input) {
+    for (const row of input.eventTypes ?? []) {
+        await upsertCatalog(payload, 'eventTypes', row);
+    }
+    for (const row of input.metrics ?? []) {
+        await upsertCatalog(payload, 'metrics', row);
+    }
+    for (const tier of input.tiers ?? []) {
+        const existing = await payload.find({
+            collection: collectionOf('tiers'),
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            where: { slug: { equals: tier.slug } },
+        });
+        const nameParts = localizedParts(tier.name);
+        const baseData = {
+            slug: tier.slug,
+            rank: tier.rank,
+            scope: tier.scope,
+            ...(tier.icon ? { icon: tier.icon } : {}),
+            ...(tier.image ? { image: tier.image } : {}),
+            unlockRules: { combinator: 'and', rules: [] },
+        };
+        let id = existing.docs[0]?.id;
+        if (id) {
+            await writeLocalizedFields(payload, {
+                collection: collectionOf('tiers'),
+                id: String(id),
+                fields: { name: tier.name, description: tier.description },
+                baseData,
+            });
+        }
+        else {
+            const created = await payload.create({
+                collection: collectionOf('tiers'),
+                data: {
+                    ...baseData,
+                    name: nameParts.en ?? tier.slug,
+                    ...(localizedParts(tier.description).en != null
+                        ? { description: localizedParts(tier.description).en }
+                        : {}),
+                },
+                locale: 'en',
+                overrideAccess: true,
+            });
+            id = String(created.id);
+            await writeLocalizedFields(payload, {
+                collection: collectionOf('tiers'),
+                id,
+                fields: { name: tier.name, description: tier.description },
+            });
+        }
+    }
+    for (const achievement of input.achievements ?? []) {
+        const existing = await payload.find({
+            collection: collectionOf('achievements'),
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            where: { slug: { equals: achievement.slug } },
+        });
+        const nameParts = localizedParts(achievement.name);
+        const descriptionParts = localizedParts(achievement.description);
+        const eligibilityRules = await resolveRuleGroup(payload, achievement.eligibilityRules);
+        const completionRules = { combinator: 'and', rules: [] };
+        const baseData = {
+            slug: achievement.slug,
+            scope: achievement.scope,
+            requiresReview: achievement.requiresReview ?? true,
+            eligibilityRules,
+            completionRules,
+        };
+        const existingId = existing.docs[0]?.id;
+        if (existingId) {
+            await writeLocalizedFields(payload, {
+                collection: collectionOf('achievements'),
+                id: String(existingId),
+                fields: { name: achievement.name, description: achievement.description },
+                baseData,
+            });
+        }
+        else {
+            const created = await payload.create({
+                collection: collectionOf('achievements'),
+                data: {
+                    ...baseData,
+                    name: nameParts.en ?? achievement.slug,
+                    ...(descriptionParts.en != null ? { description: descriptionParts.en } : {}),
+                },
+                locale: 'en',
+                overrideAccess: true,
+            });
+            const id = String(created.id);
+            await writeLocalizedFields(payload, {
+                collection: collectionOf('achievements'),
+                id,
+                fields: { name: achievement.name, description: achievement.description },
+            });
+        }
+    }
+    for (const achievement of input.achievements ?? []) {
+        if (!achievement.completionRules)
+            continue;
+        const hasRules = Array.isArray(achievement.completionRules)
+            ? achievement.completionRules.length > 0
+            : Boolean(achievement.completionRules.rules?.length);
+        if (!hasRules)
+            continue;
+        const existing = await payload.find({
+            collection: collectionOf('achievements'),
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            where: { slug: { equals: achievement.slug } },
+        });
+        const doc = existing.docs[0];
+        if (!doc)
+            continue;
+        await payload.update({
+            collection: collectionOf('achievements'),
+            id: doc.id,
+            data: {
+                completionRules: await resolveRuleGroup(payload, achievement.completionRules),
+            },
+            overrideAccess: true,
+        });
+    }
+    // Unlock rules can reference achievements — apply after those rows exist.
+    for (const tier of input.tiers ?? []) {
+        if (!tier.unlockRules)
+            continue;
+        const hasRules = Array.isArray(tier.unlockRules)
+            ? tier.unlockRules.length > 0
+            : Boolean(tier.unlockRules.rules?.length);
+        if (!hasRules)
+            continue;
+        const existing = await payload.find({
+            collection: collectionOf('tiers'),
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            where: { slug: { equals: tier.slug } },
+        });
+        const doc = existing.docs[0];
+        if (!doc)
+            continue;
+        await payload.update({
+            collection: collectionOf('tiers'),
+            id: doc.id,
+            data: {
+                unlockRules: await resolveRuleGroup(payload, tier.unlockRules),
+            },
+            overrideAccess: true,
+        });
+    }
+    for (const slug of input.removeAchievementSlugs ?? []) {
+        const id = await findIdBySlug(payload, 'achievements', slug);
+        if (!id)
+            continue;
+        try {
+            await payload.delete({
+                collection: collectionOf('achievements'),
+                id,
+                overrideAccess: true,
+            });
+        }
+        catch (error) {
+            payload.logger.warn(`Could not remove obsolete achievement slug "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist/services/achievement/buildCatalogProgressGroups.d.ts

@@ -0,0 +1,37 @@
+export type CatalogProgressItem = {
+    id: string;
+    name?: string;
+    slug?: string;
+    description?: string;
+    completedAt?: string | null;
+    earned: boolean;
+};
+export type CatalogProgressGroup = {
+    id: string;
+    title: string;
+    slug?: string;
+    description?: string;
+    items: CatalogProgressItem[];
+};
+type CatalogDoc = {
+    id: string;
+    name?: string;
+    slug?: string;
+    description?: string | null;
+    completionRules?: unknown;
+};
+type GrantDoc = {
+    id: string;
+    completedAt?: string | null;
+    achievement?: unknown;
+};
+/**
+ * Groups catalog achievements by composite parents (`completionRules`).
+ * Children follow completion-rule order. Unearned children stay in the list with `earned: false`.
+ */
+export declare function buildCatalogProgressGroups(args: {
+    achievements: CatalogDoc[];
+    grants: GrantDoc[];
+}): CatalogProgressGroup[];
+export {};
+//# sourceMappingURL=buildCatalogProgressGroups.d.ts.map

package/dist/services/achievement/buildCatalogProgressGroups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildCatalogProgressGroups.d.ts","sourceRoot":"","sources":["../../../src/services/achievement/buildCatalogProgressGroups.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,mBAAmB,EAAE,CAAA;CAC7B,CAAA;AAED,KAAK,UAAU,GAAG;IAChB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAWD;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,YAAY,EAAE,UAAU,EAAE,CAAA;IAC1B,MAAM,EAAE,QAAQ,EAAE,CAAA;CACnB,GAAG,oBAAoB,EAAE,CA2DzB"}

package/dist/services/achievement/buildCatalogProgressGroups.js

@@ -0,0 +1,70 @@
+import { relationId } from './relationId';
+import { collectAchievementCompleteRefs } from './evaluateRules';
+function grantKey(achievement) {
+    const id = relationId(achievement);
+    const slug = achievement && typeof achievement === 'object' && 'slug' in achievement
+        ? String(achievement.slug ?? '')
+        : '';
+    return { id, slug };
+}
+/**
+ * Groups catalog achievements by composite parents (`completionRules`).
+ * Children follow completion-rule order. Unearned children stay in the list with `earned: false`.
+ */
+export function buildCatalogProgressGroups(args) {
+    const grantsById = new Map();
+    const grantsBySlug = new Map();
+    for (const grant of args.grants) {
+        const key = grantKey(grant.achievement);
+        if (key.id)
+            grantsById.set(key.id, grant);
+        if (key.slug)
+            grantsBySlug.set(key.slug, grant);
+    }
+    const byId = new Map(args.achievements.map((doc) => [doc.id, doc]));
+    const bySlug = new Map(args.achievements
+        .filter((doc) => doc.slug)
+        .map((doc) => [String(doc.slug), doc]));
+    const toItem = (doc) => {
+        const grant = grantsById.get(doc.id) ?? (doc.slug ? grantsBySlug.get(doc.slug) : undefined);
+        return {
+            id: doc.id,
+            earned: Boolean(grant),
+            ...(typeof doc.name === 'string' && doc.name ? { name: doc.name } : {}),
+            ...(typeof doc.slug === 'string' && doc.slug ? { slug: doc.slug } : {}),
+            ...(typeof doc.description === 'string' && doc.description
+                ? { description: doc.description }
+                : {}),
+            completedAt: grant?.completedAt ?? null,
+        };
+    };
+    const parents = [];
+    for (const doc of args.achievements) {
+        const refs = collectAchievementCompleteRefs(doc.completionRules);
+        if (refs.length === 0)
+            continue;
+        parents.push(doc);
+    }
+    const groups = parents.map((parent) => {
+        const refs = collectAchievementCompleteRefs(parent.completionRules);
+        const items = [];
+        const seen = new Set();
+        for (const ref of refs) {
+            const child = (ref.id && byId.get(ref.id)) || (ref.slug ? bySlug.get(ref.slug) : undefined);
+            if (!child || seen.has(child.id))
+                continue;
+            seen.add(child.id);
+            items.push(toItem(child));
+        }
+        return {
+            id: parent.id,
+            title: parent.name || parent.slug || parent.id,
+            ...(parent.slug ? { slug: parent.slug } : {}),
+            ...(typeof parent.description === 'string' && parent.description
+                ? { description: parent.description }
+                : {}),
+            items,
+        };
+    });
+    return groups;
+}

package/dist/services/achievement/builtInRules.d.ts

@@ -0,0 +1,3 @@
+import type { AchievementRuleType } from '../../types';
+export declare const builtInRuleTypes: AchievementRuleType[];
+//# sourceMappingURL=builtInRules.d.ts.map

package/dist/services/achievement/builtInRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtInRules.d.ts","sourceRoot":"","sources":["../../../src/services/achievement/builtInRules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,mBAAmB,EAAE,MAAM,aAAa,CAAA;AA2K/E,eAAO,MAAM,gBAAgB,EAAE,mBAAmB,EAiJjD,CAAA"}