@dappermountain/payload-plugin-achievements 0.1.0

package/dist/services/achievement/builtInRules.js

@@ -0,0 +1,280 @@
+import { collectionOf } from '../../collections/helpers';
+import { relationId } from './relationId';
+import { userScopeIncludingUnscopedWhere, userScopeWhere } from './where';
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+async function resolveMetricId(args) {
+    const metricId = relationId(args.rule.metric);
+    if (metricId)
+        return metricId;
+    const metricSlug = typeof args.rule.metricSlug === 'string' ? args.rule.metricSlug : '';
+    if (!metricSlug)
+        return null;
+    const found = await args.payload.find({
+        collection: collectionOf('metrics'),
+        depth: 0,
+        limit: 1,
+        overrideAccess: true,
+        where: { slug: { equals: metricSlug } },
+    });
+    return relationId(found.docs[0]);
+}
+async function metricValue(args) {
+    const logs = await args.payload.find({
+        collection: collectionOf('logs'),
+        depth: 0,
+        limit: 1000,
+        pagination: false,
+        overrideAccess: true,
+        where: {
+            and: [userScopeWhere(args.userId, args.scopeId), { metric: { equals: args.metricId } }],
+        },
+    });
+    return logs.docs.reduce((sum, doc) => {
+        const change = doc.change;
+        return sum + (typeof change === 'number' && Number.isFinite(change) ? change : 0);
+    }, 0);
+}
+async function resolveEventTypeId(args) {
+    let eventTypeId = relationId(args.rule.eventType);
+    if (eventTypeId) {
+        // Seeded rules may store a slug string in `eventType` before resolve; only treat
+        // opaque ids as final when a catalog row exists.
+        const byId = await args.payload.find({
+            collection: collectionOf('eventTypes'),
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            where: { id: { equals: eventTypeId } },
+        });
+        if (relationId(byId.docs[0]))
+            return eventTypeId;
+    }
+    const slugCandidate = (typeof args.rule.eventTypeSlug === 'string' && args.rule.eventTypeSlug) ||
+        (typeof args.rule.eventType === 'string' && args.rule.eventType) ||
+        '';
+    if (!slugCandidate)
+        return null;
+    const found = await args.payload.find({
+        collection: collectionOf('eventTypes'),
+        depth: 0,
+        limit: 1,
+        overrideAccess: true,
+        where: { slug: { equals: slugCandidate } },
+    });
+    return relationId(found.docs[0]);
+}
+async function resolveAchievementRef(args) {
+    let requiredId = relationId(args.rule.achievement);
+    let requiredSlug = typeof args.rule.achievementSlug === 'string' ? args.rule.achievementSlug : '';
+    let eligibilityRules;
+    let completionRules;
+    if (!requiredId && requiredSlug) {
+        const found = await args.payload.find({
+            collection: collectionOf('achievements'),
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            where: args.scopeId
+                ? {
+                    and: [{ slug: { equals: requiredSlug } }, { scope: { equals: args.scopeId } }],
+                }
+                : { slug: { equals: requiredSlug } },
+        });
+        const doc = found.docs[0];
+        requiredId = relationId(doc);
+        requiredSlug = String(doc?.slug ?? requiredSlug);
+        eligibilityRules = doc?.eligibilityRules;
+        completionRules = doc?.completionRules;
+    }
+    if (requiredId && (eligibilityRules === undefined || completionRules === undefined || !requiredSlug)) {
+        const doc = (await args.payload.findByID({
+            collection: collectionOf('achievements'),
+            id: requiredId,
+            depth: 0,
+            overrideAccess: true,
+        }));
+        requiredSlug = requiredSlug || String(doc?.slug ?? '');
+        eligibilityRules = eligibilityRules ?? doc?.eligibilityRules;
+        completionRules = completionRules ?? doc?.completionRules;
+    }
+    return { id: requiredId, slug: requiredSlug, eligibilityRules, completionRules };
+}
+async function isAchievementGranted(args) {
+    if (!args.requiredId && !args.requiredSlug)
+        return false;
+    const grantClauses = [{ user: { equals: args.userId } }];
+    if (args.scopeId)
+        grantClauses.push({ scope: { equals: args.scopeId } });
+    if (args.requiredId)
+        grantClauses.push({ achievement: { equals: args.requiredId } });
+    const grants = await args.payload.find({
+        collection: collectionOf('grants'),
+        depth: args.requiredSlug && !args.requiredId ? 1 : 0,
+        limit: args.requiredId ? 1 : 50,
+        overrideAccess: true,
+        where: { and: grantClauses },
+    });
+    if (args.requiredId)
+        return grants.docs.length > 0;
+    return grants.docs.some((doc) => {
+        const achievement = doc.achievement;
+        if (achievement && typeof achievement === 'object') {
+            return achievement.slug === args.requiredSlug;
+        }
+        return false;
+    });
+}
+export const builtInRuleTypes = [
+    {
+        type: 'tier-at-least',
+        progressRole: 'gate',
+        async evaluate({ payload, req, rule, userId, scopeId, ladderRank }) {
+            const tierId = relationId(rule.tier);
+            let requiredRank;
+            if (tierId) {
+                const tier = (await payload.findByID({
+                    collection: collectionOf('tiers'),
+                    id: tierId,
+                    depth: 0,
+                    overrideAccess: true,
+                }));
+                requiredRank = tier?.rank;
+            }
+            else {
+                const tierSlug = String(rule.tierSlug ?? '');
+                if (!tierSlug)
+                    return false;
+                const tiers = await payload.find({
+                    collection: collectionOf('tiers'),
+                    depth: 0,
+                    limit: 1,
+                    overrideAccess: true,
+                    where: scopeId
+                        ? { and: [{ slug: { equals: tierSlug } }, { scope: { equals: scopeId } }] }
+                        : { slug: { equals: tierSlug } },
+                });
+                requiredRank = tiers.docs[0]?.rank;
+            }
+            if (typeof requiredRank !== 'number')
+                return false;
+            let currentRank = ladderRank;
+            if (currentRank === undefined) {
+                const { resolveCurrentTier } = await import('./resolveCurrentTier');
+                const current = await resolveCurrentTier({
+                    payload,
+                    req,
+                    userId,
+                    scopeId,
+                });
+                currentRank = current?.rank ?? null;
+            }
+            return typeof currentRank === 'number' && currentRank >= requiredRank;
+        },
+    },
+    {
+        type: 'achievement-complete',
+        async evaluate({ payload, rule, userId, scopeId }) {
+            const ref = await resolveAchievementRef({ payload, rule, scopeId });
+            return isAchievementGranted({
+                payload,
+                userId,
+                scopeId,
+                requiredId: ref.id,
+                requiredSlug: ref.slug,
+            });
+        },
+        async progress(args) {
+            const { payload, req, rule, userId, scopeId, ladderRank, progressVisited } = args;
+            const ref = await resolveAchievementRef({ payload, rule, scopeId });
+            if (!ref.id && !ref.slug)
+                return 0;
+            const granted = await isAchievementGranted({
+                payload,
+                userId,
+                scopeId,
+                requiredId: ref.id,
+                requiredSlug: ref.slug,
+            });
+            if (granted)
+                return 1;
+            const visitKey = ref.id || ref.slug;
+            const visited = progressVisited ?? new Set();
+            if (visited.has(visitKey))
+                return 0;
+            visited.add(visitKey);
+            const { evaluateRuleProgress, ruleGroupHasProgressRequirements } = await import('./evaluateRules');
+            const composition = ruleGroupHasProgressRequirements(ref.completionRules)
+                ? ref.completionRules
+                : ref.eligibilityRules;
+            if (!ruleGroupHasProgressRequirements(composition))
+                return 0;
+            return evaluateRuleProgress({
+                payload,
+                req,
+                rules: composition,
+                userId,
+                scopeId,
+                ladderRank,
+                progressVisited: visited,
+            });
+        },
+    },
+    {
+        type: 'metric-minimum',
+        async evaluate({ payload, rule, userId, scopeId }) {
+            const resolvedId = await resolveMetricId({ payload, rule });
+            if (!resolvedId)
+                return false;
+            const minimum = Number(rule.minimum ?? 0);
+            const value = await metricValue({ payload, userId, scopeId, metricId: resolvedId });
+            return value >= minimum;
+        },
+        async progress({ payload, rule, userId, scopeId }) {
+            const resolvedId = await resolveMetricId({ payload, rule });
+            if (!resolvedId)
+                return 0;
+            const minimum = Number(rule.minimum ?? 0);
+            if (!(minimum > 0))
+                return 1;
+            const value = await metricValue({ payload, userId, scopeId, metricId: resolvedId });
+            return clamp01(value / minimum);
+        },
+    },
+    {
+        type: 'event-count',
+        async evaluate({ payload, rule, userId, scopeId }) {
+            const eventTypeId = await resolveEventTypeId({ payload, rule });
+            if (!eventTypeId)
+                return false;
+            const needed = Number(rule.count ?? 1);
+            const result = await payload.count({
+                collection: collectionOf('logs'),
+                overrideAccess: true,
+                where: {
+                    and: [userScopeIncludingUnscopedWhere(userId, scopeId), { type: { equals: eventTypeId } }],
+                },
+            });
+            return result.totalDocs >= needed;
+        },
+        async progress({ payload, rule, userId, scopeId }) {
+            const eventTypeId = await resolveEventTypeId({ payload, rule });
+            if (!eventTypeId)
+                return 0;
+            const needed = Number(rule.count ?? 1);
+            if (!(needed > 0))
+                return 1;
+            const result = await payload.count({
+                collection: collectionOf('logs'),
+                overrideAccess: true,
+                where: {
+                    and: [userScopeIncludingUnscopedWhere(userId, scopeId), { type: { equals: eventTypeId } }],
+                },
+            });
+            return clamp01(result.totalDocs / needed);
+        },
+    },
+];

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

@@ -0,0 +1,48 @@
+import type { PayloadRequest } from 'payload';
+export type RuleGroup = {
+    combinator?: 'and' | 'or' | null;
+    rules?: Record<string, unknown>[] | null;
+};
+export declare function normalizeRuleGroup(input: RuleGroup | Record<string, unknown>[] | null | undefined): {
+    combinator: 'and' | 'or';
+    rules: Record<string, unknown>[];
+};
+/** True when the tree has at least one non-gate requirement (nested achievements, counts, metrics). */
+export declare function ruleGroupHasProgressRequirements(input: RuleGroup | Record<string, unknown>[] | null | undefined): boolean;
+export type AchievementCompleteRef = {
+    id: string | null;
+    slug: string;
+};
+/**
+ * Achievement-complete leaves in document order (nested groups included).
+ * First appearance wins when the same achievement is listed twice.
+ */
+export declare function collectAchievementCompleteRefs(input: RuleGroup | Record<string, unknown>[] | null | undefined): AchievementCompleteRef[];
+export declare function evaluateRules(args: {
+    payload: PayloadRequest['payload'];
+    req: PayloadRequest;
+    rules: RuleGroup | Record<string, unknown>[] | null | undefined;
+    userId: string;
+    scopeId: string | null;
+    /** Rank unlocked so far during a ladder walk (`null` = none). */
+    ladderRank?: number | null;
+}): Promise<boolean>;
+/**
+ * Fractional progress (0..1) toward satisfying a rule tree.
+ *
+ * Derived from the tree — no catalog `weight` field:
+ * - **AND**: equal average of *requirement* children (`tier-at-least` is a gate and is skipped).
+ * - **OR**: best child (max).
+ * - Leaves: rule-type `progress` when provided; `achievement-complete` rolls up nested
+ *   eligibility when the grant is missing; otherwise `evaluate` → 0|1.
+ */
+export declare function evaluateRuleProgress(args: {
+    payload: PayloadRequest['payload'];
+    req: PayloadRequest;
+    rules: RuleGroup | Record<string, unknown>[] | null | undefined;
+    userId: string;
+    scopeId: string | null;
+    ladderRank?: number | null;
+    progressVisited?: Set<string>;
+}): Promise<number>;
+//# sourceMappingURL=evaluateRules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evaluateRules.d.ts","sourceRoot":"","sources":["../../../src/services/achievement/evaluateRules.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI,CAAA;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,CAAA;CACzC,CAAA;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAC9D;IAAE,UAAU,EAAE,KAAK,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;CAAE,CAOhE;AAED,uGAAuG;AACvG,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAC9D,OAAO,CAET;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAC9D,sBAAsB,EAAE,CA4B1B;AAgBD,wBAAsB,aAAa,CAAC,IAAI,EAAE;IACxC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,CAAA;IAClC,GAAG,EAAE,cAAc,CAAA;IACnB,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,CAAA;IAC/D,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B,GAAG,OAAO,CAAC,OAAO,CAAC,CAUnB;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE;IAC/C,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,CAAA;IAClC,GAAG,EAAE,cAAc,CAAA;IACnB,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,CAAA;IAC/D,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAC9B,GAAG,OAAO,CAAC,MAAM,CAAC,CAWlB"}

package/dist/services/achievement/evaluateRules.js

@@ -0,0 +1,206 @@
+import { relationId } from './relationId';
+import { getRuleTypeMap } from '../../extensions/registry';
+export function normalizeRuleGroup(input) {
+    if (!input)
+        return { combinator: 'and', rules: [] };
+    if (Array.isArray(input))
+        return { combinator: 'and', rules: input };
+    return {
+        combinator: input.combinator === 'or' ? 'or' : 'and',
+        rules: input.rules ?? [],
+    };
+}
+/** True when the tree has at least one non-gate requirement (nested achievements, counts, metrics). */
+export function ruleGroupHasProgressRequirements(input) {
+    return normalizeRuleGroup(input).rules.some((rule) => contributesToProgress(rule));
+}
+/**
+ * Achievement-complete leaves in document order (nested groups included).
+ * First appearance wins when the same achievement is listed twice.
+ */
+export function collectAchievementCompleteRefs(input) {
+    const out = [];
+    const seen = new Set();
+    const walk = (rules) => {
+        for (const rule of rules) {
+            if (rule.type === 'group' && Array.isArray(rule.rules)) {
+                walk(rule.rules);
+                continue;
+            }
+            if (rule.type !== 'achievement-complete')
+                continue;
+            const id = relationId(rule.achievement);
+            const populatedSlug = rule.achievement && typeof rule.achievement === 'object' && 'slug' in rule.achievement
+                ? String(rule.achievement.slug ?? '')
+                : '';
+            const slug = (typeof rule.achievementSlug === 'string' ? rule.achievementSlug : '') || populatedSlug;
+            const key = id || slug;
+            if (!key || seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ id, slug });
+        }
+    };
+    walk(normalizeRuleGroup(input).rules);
+    return out;
+}
+function clamp01(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}
+function contributesToProgress(rule) {
+    if (rule.type === 'group') {
+        const children = Array.isArray(rule.rules) ? rule.rules : [];
+        return children.some((child) => contributesToProgress(child));
+    }
+    const impl = getRuleTypeMap().get(String(rule.type ?? ''));
+    return impl?.progressRole !== 'gate';
+}
+export async function evaluateRules(args) {
+    return evaluateGroup({
+        payload: args.payload,
+        req: args.req,
+        group: normalizeRuleGroup(args.rules),
+        userId: args.userId,
+        scopeId: args.scopeId,
+        ladderRank: args.ladderRank,
+        isRoot: true,
+    });
+}
+/**
+ * Fractional progress (0..1) toward satisfying a rule tree.
+ *
+ * Derived from the tree — no catalog `weight` field:
+ * - **AND**: equal average of *requirement* children (`tier-at-least` is a gate and is skipped).
+ * - **OR**: best child (max).
+ * - Leaves: rule-type `progress` when provided; `achievement-complete` rolls up nested
+ *   eligibility when the grant is missing; otherwise `evaluate` → 0|1.
+ */
+export async function evaluateRuleProgress(args) {
+    return progressGroup({
+        payload: args.payload,
+        req: args.req,
+        group: normalizeRuleGroup(args.rules),
+        userId: args.userId,
+        scopeId: args.scopeId,
+        ladderRank: args.ladderRank,
+        progressVisited: args.progressVisited,
+        isRoot: true,
+    });
+}
+async function evaluateGroup(args) {
+    const { combinator, rules } = args.group;
+    if (rules.length === 0) {
+        if (args.isRoot)
+            return true;
+        return combinator !== 'or';
+    }
+    const map = getRuleTypeMap();
+    const evalNode = async (rule) => {
+        if (rule.type === 'group') {
+            return evaluateGroup({
+                payload: args.payload,
+                req: args.req,
+                group: {
+                    combinator: rule.combinator === 'or' ? 'or' : 'and',
+                    rules: Array.isArray(rule.rules) ? rule.rules : [],
+                },
+                userId: args.userId,
+                scopeId: args.scopeId,
+                ladderRank: args.ladderRank,
+                isRoot: false,
+            });
+        }
+        const type = String(rule.type ?? '');
+        const impl = map.get(type);
+        if (!impl)
+            return false;
+        return Boolean(await impl.evaluate({
+            payload: args.payload,
+            req: args.req,
+            rule,
+            userId: args.userId,
+            scopeId: args.scopeId,
+            ladderRank: args.ladderRank,
+        }));
+    };
+    if (combinator === 'or') {
+        for (const rule of rules) {
+            if (await evalNode(rule))
+                return true;
+        }
+        return false;
+    }
+    for (const rule of rules) {
+        if (!(await evalNode(rule)))
+            return false;
+    }
+    return true;
+}
+async function progressGroup(args) {
+    const { combinator, rules } = args.group;
+    if (rules.length === 0) {
+        if (args.isRoot)
+            return 1;
+        return combinator === 'or' ? 0 : 1;
+    }
+    const map = getRuleTypeMap();
+    const evalArgs = (rule) => ({
+        payload: args.payload,
+        req: args.req,
+        rule,
+        userId: args.userId,
+        scopeId: args.scopeId,
+        ladderRank: args.ladderRank,
+        progressVisited: args.progressVisited,
+    });
+    const progressNode = async (rule) => {
+        if (rule.type === 'group') {
+            return progressGroup({
+                payload: args.payload,
+                req: args.req,
+                group: {
+                    combinator: rule.combinator === 'or' ? 'or' : 'and',
+                    rules: Array.isArray(rule.rules) ? rule.rules : [],
+                },
+                userId: args.userId,
+                scopeId: args.scopeId,
+                ladderRank: args.ladderRank,
+                progressVisited: args.progressVisited,
+                isRoot: false,
+            });
+        }
+        const type = String(rule.type ?? '');
+        const impl = map.get(type);
+        if (!impl)
+            return 0;
+        if (impl.progress) {
+            return clamp01(Number(await impl.progress(evalArgs(rule))));
+        }
+        const passed = await impl.evaluate(evalArgs(rule));
+        return passed ? 1 : 0;
+    };
+    if (combinator === 'or') {
+        let best = 0;
+        for (const rule of rules) {
+            best = Math.max(best, await progressNode(rule));
+            if (best >= 1)
+                return 1;
+        }
+        return best;
+    }
+    const requirements = rules.filter((rule) => contributesToProgress(rule));
+    if (requirements.length === 0) {
+        for (const rule of rules) {
+            if ((await progressNode(rule)) < 1)
+                return 0;
+        }
+        return 1;
+    }
+    let sum = 0;
+    for (const rule of requirements) {
+        sum += await progressNode(rule);
+    }
+    return clamp01(sum / requirements.length);
+}

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

@@ -0,0 +1,24 @@
+import type { Payload, PayloadRequest } from 'payload';
+export type EventTypeFlags = {
+    requiresActor: boolean;
+    requiresMetric: boolean;
+};
+/** Read flags from a loaded event-type document (or populated relationship). */
+export declare function readEventTypeFlags(doc: unknown): EventTypeFlags | null;
+/** Flags from an event-type catalog row (or its id). */
+export declare function getEventTypeFlags(args: {
+    payload: Payload;
+    req?: PayloadRequest;
+    typeIdOrDoc: unknown;
+}): Promise<EventTypeFlags>;
+export declare function eventTypeRequiresActor(args: {
+    payload: Payload;
+    req?: PayloadRequest;
+    typeIdOrDoc: unknown;
+}): Promise<boolean>;
+export declare function eventTypeRequiresMetric(args: {
+    payload: Payload;
+    req?: PayloadRequest;
+    typeIdOrDoc: unknown;
+}): Promise<boolean>;
+//# sourceMappingURL=eventTypeRequiresActor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventTypeRequiresActor.d.ts","sourceRoot":"","sources":["../../../src/services/achievement/eventTypeRequiresActor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAKtD,MAAM,MAAM,cAAc,GAAG;IAC3B,aAAa,EAAE,OAAO,CAAA;IACtB,cAAc,EAAE,OAAO,CAAA;CACxB,CAAA;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAUtE;AAMD,wDAAwD;AACxD,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB,WAAW,EAAE,OAAO,CAAA;CACrB,GAAG,OAAO,CAAC,cAAc,CAAC,CAsB1B;AAED,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IACjD,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB,WAAW,EAAE,OAAO,CAAA;CACrB,GAAG,OAAO,CAAC,OAAO,CAAC,CAEnB;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB,WAAW,EAAE,OAAO,CAAA;CACrB,GAAG,OAAO,CAAC,OAAO,CAAC,CAEnB"}

package/dist/services/achievement/eventTypeRequiresActor.js

@@ -0,0 +1,46 @@
+import { collectionOf } from '../../collections/helpers';
+import { relationId } from './relationId';
+/** Read flags from a loaded event-type document (or populated relationship). */
+export function readEventTypeFlags(doc) {
+    if (!doc || typeof doc !== 'object')
+        return null;
+    const row = doc;
+    const hasFlagKeys = 'requiresActor' in row || 'requiresMetric' in row || typeof row.slug === 'string';
+    if (!hasFlagKeys)
+        return null;
+    return {
+        requiresActor: Boolean(row.requiresActor),
+        requiresMetric: Boolean(row.requiresMetric) || row.slug === 'metric.delta',
+    };
+}
+function flagsFromDoc(doc) {
+    return readEventTypeFlags(doc);
+}
+/** Flags from an event-type catalog row (or its id). */
+export async function getEventTypeFlags(args) {
+    const embedded = flagsFromDoc(args.typeIdOrDoc);
+    if (embedded && args.typeIdOrDoc && typeof args.typeIdOrDoc === 'object') {
+        const row = args.typeIdOrDoc;
+        if ('requiresActor' in row || 'requiresMetric' in row || 'slug' in row) {
+            return embedded;
+        }
+    }
+    const typeId = relationId(args.typeIdOrDoc);
+    if (!typeId)
+        return { requiresActor: false, requiresMetric: false };
+    const found = (await args.payload.findByID({
+        collection: collectionOf('eventTypes'),
+        id: typeId,
+        depth: 0,
+        overrideAccess: true,
+        req: args.req,
+        select: { requiresActor: true, requiresMetric: true, slug: true },
+    }));
+    return flagsFromDoc(found) ?? { requiresActor: false, requiresMetric: false };
+}
+export async function eventTypeRequiresActor(args) {
+    return (await getEventTypeFlags(args)).requiresActor;
+}
+export async function eventTypeRequiresMetric(args) {
+    return (await getEventTypeFlags(args)).requiresMetric;
+}

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

@@ -0,0 +1,53 @@
+import type { PaginatedDocs, Payload, PayloadRequest } from 'payload';
+type LeanCatalog = {
+    id: string;
+    name?: string;
+    slug?: string;
+    description?: string;
+};
+type LeanTier = LeanCatalog & {
+    rank?: number;
+    scopeId?: string | null;
+};
+export type GetUserProgressPaging = {
+    limit?: number;
+    page?: number;
+    requestsLimit?: number;
+};
+declare function leanGrant(doc: Record<string, unknown>): {
+    id: unknown;
+    achievement: LeanCatalog | null;
+    completedAt: {} | null;
+    note: {} | null;
+    scopeId: string | null;
+    updatedAt: {} | null;
+    createdAt: {} | null;
+};
+declare function leanRequest(doc: Record<string, unknown>): {
+    id: unknown;
+    status: {} | null;
+    achievement: LeanCatalog | null;
+    reason: {} | null;
+    updatedAt: {} | null;
+    createdAt: {} | null;
+};
+export type UserProgressMeResponse = PaginatedDocs<ReturnType<typeof leanGrant>> & {
+    /** Ladder-derived current tier(s). */
+    tiers: LeanTier[];
+    requests: ReturnType<typeof leanRequest>[];
+};
+/**
+ * Current-user snapshot. Top-level Payload `find` shape for **grants**;
+ * ladder-derived `tiers` and lean `requests` ride along.
+ */
+export declare function getUserProgress(args: {
+    payload: Payload;
+    req?: PayloadRequest;
+    userId: string;
+    scopeId?: string | null;
+    paging?: GetUserProgressPaging;
+    /** Content locale for localized achievement / tier names (falls back to `req.locale`). */
+    locale?: string;
+}): Promise<UserProgressMeResponse>;
+export {};
+//# sourceMappingURL=getUserProgress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getUserProgress.d.ts","sourceRoot":"","sources":["../../../src/services/achievement/getUserProgress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAOrE,KAAK,WAAW,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AACrF,KAAK,QAAQ,GAAG,WAAW,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAExE,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAiBD,iBAAS,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;EAU9C;AAED,iBAAS,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;EAShD;AAoBD,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC,GAAG;IACjF,sCAAsC;IACtC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,QAAQ,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,EAAE,CAAA;CAC3C,CAAA;AAkED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,CAAC,EAAE,qBAAqB,CAAA;IAC9B,0FAA0F;IAC1F,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAiDlC"}