@memberjunction/server 5.35.0 → 5.37.0

package/dist/resolvers/ListOperationsResolver.js

@@ -0,0 +1,930 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { LogError } from '@memberjunction/core';
+import { ListOperations, ListSharing } from '@memberjunction/lists';
+import { Arg, Ctx, Field, InputType, Int, Mutation, ObjectType, Query, Resolver } from 'type-graphql';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { GetReadWriteProvider } from '../util.js';
+// ---------------------------------------------------------------------------
+// GraphQL types — mirror the @memberjunction/lists shape one-to-one.
+//
+// Why duplicate: GraphQL types must be decorated with `@ObjectType` /
+// `@InputType` / `@Field`, but @memberjunction/lists is intentionally
+// framework-agnostic and ships zero type-graphql metadata. The duplication
+// stays cheap because there's a single converter at each boundary
+// (`fromCoreDelta`, `toCoreSource`) — drift gets caught at compile time
+// when fields change shape.
+// ---------------------------------------------------------------------------
+/**
+ * Discriminated source descriptor as a flat input. GraphQL does not support
+ * tagged unions in inputs, so we encode the discriminator in `Kind` and
+ * the variant-specific payload in optional fields. Runtime validation
+ * enforces the right field-presence per kind.
+ */
+let ListSourceInput = class ListSourceInput {
+};
+__decorate([
+    Field(() => String, { description: 'Discriminator. One of: list | view | adhoc.' }),
+    __metadata("design:type", String)
+], ListSourceInput.prototype, "Kind", void 0);
+__decorate([
+    Field(() => String, { nullable: true, description: 'List ID, required when Kind=list.' }),
+    __metadata("design:type", String)
+], ListSourceInput.prototype, "ListID", void 0);
+__decorate([
+    Field(() => String, { nullable: true, description: 'User View ID, required when Kind=view.' }),
+    __metadata("design:type", String)
+], ListSourceInput.prototype, "ViewID", void 0);
+__decorate([
+    Field(() => String, { nullable: true, description: 'Entity name, required when Kind=adhoc.' }),
+    __metadata("design:type", String)
+], ListSourceInput.prototype, "EntityName", void 0);
+__decorate([
+    Field(() => String, { nullable: true, description: 'WHERE clause expression, required when Kind=adhoc.' }),
+    __metadata("design:type", String)
+], ListSourceInput.prototype, "ExtraFilter", void 0);
+ListSourceInput = __decorate([
+    InputType('ListSourceInput')
+], ListSourceInput);
+export { ListSourceInput };
+let MaterializeOptionsInput = class MaterializeOptionsInput {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], MaterializeOptionsInput.prototype, "ListName", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], MaterializeOptionsInput.prototype, "CategoryId", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], MaterializeOptionsInput.prototype, "Description", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], MaterializeOptionsInput.prototype, "RememberLineage", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], MaterializeOptionsInput.prototype, "UseSnapshot", void 0);
+__decorate([
+    Field(() => String, { description: 'Refresh mode: Additive | Sync.' }),
+    __metadata("design:type", String)
+], MaterializeOptionsInput.prototype, "RefreshMode", void 0);
+MaterializeOptionsInput = __decorate([
+    InputType('MaterializeOptionsInput')
+], MaterializeOptionsInput);
+export { MaterializeOptionsInput };
+let ListDeltaCountsType = class ListDeltaCountsType {
+};
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ListDeltaCountsType.prototype, "Add", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ListDeltaCountsType.prototype, "Remove", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ListDeltaCountsType.prototype, "Unchanged", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ListDeltaCountsType.prototype, "SourceTotal", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ListDeltaCountsType.prototype, "TargetTotal", void 0);
+ListDeltaCountsType = __decorate([
+    ObjectType('ListDeltaCountsType')
+], ListDeltaCountsType);
+export { ListDeltaCountsType };
+let ListDeltaWarningType = class ListDeltaWarningType {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListDeltaWarningType.prototype, "Code", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListDeltaWarningType.prototype, "Message", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ListDeltaWarningType.prototype, "DetailsJSON", void 0);
+ListDeltaWarningType = __decorate([
+    ObjectType('ListDeltaWarningType')
+], ListDeltaWarningType);
+export { ListDeltaWarningType };
+let ListDeltaType = class ListDeltaType {
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ListDeltaType.prototype, "TargetListId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListDeltaType.prototype, "EntityName", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], ListDeltaType.prototype, "ToAdd", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], ListDeltaType.prototype, "ToRemove", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], ListDeltaType.prototype, "Unchanged", void 0);
+__decorate([
+    Field(() => ListDeltaCountsType),
+    __metadata("design:type", ListDeltaCountsType)
+], ListDeltaType.prototype, "Counts", void 0);
+__decorate([
+    Field(() => [ListDeltaWarningType]),
+    __metadata("design:type", Array)
+], ListDeltaType.prototype, "Warnings", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListDeltaType.prototype, "DeltaToken", void 0);
+ListDeltaType = __decorate([
+    ObjectType('ListDeltaType')
+], ListDeltaType);
+export { ListDeltaType };
+let ApplyListResultType = class ApplyListResultType {
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], ApplyListResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ApplyListResultType.prototype, "ResultCode", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ApplyListResultType.prototype, "Message", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ApplyListResultType.prototype, "CreatedListId", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ApplyListResultType.prototype, "TargetListId", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], ApplyListResultType.prototype, "AddedCount", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], ApplyListResultType.prototype, "RemovedCount", void 0);
+__decorate([
+    Field(() => Int, { nullable: true }),
+    __metadata("design:type", Number)
+], ApplyListResultType.prototype, "FailedCount", void 0);
+__decorate([
+    Field(() => [String], { nullable: true }),
+    __metadata("design:type", Array)
+], ApplyListResultType.prototype, "Errors", void 0);
+ApplyListResultType = __decorate([
+    ObjectType('ApplyListResultType')
+], ApplyListResultType);
+export { ApplyListResultType };
+let ComputeDeltaInput = class ComputeDeltaInput {
+};
+__decorate([
+    Field(() => String, { description: 'TargetListId, or the literal string "new" to materialize.' }),
+    __metadata("design:type", String)
+], ComputeDeltaInput.prototype, "Target", void 0);
+__decorate([
+    Field(() => ListSourceInput),
+    __metadata("design:type", ListSourceInput)
+], ComputeDeltaInput.prototype, "Source", void 0);
+__decorate([
+    Field(() => String, { description: 'Refresh mode: Additive | Sync.' }),
+    __metadata("design:type", String)
+], ComputeDeltaInput.prototype, "Mode", void 0);
+ComputeDeltaInput = __decorate([
+    InputType('ComputeDeltaInput')
+], ComputeDeltaInput);
+export { ComputeDeltaInput };
+let ApplyDeltaInput = class ApplyDeltaInput {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ApplyDeltaInput.prototype, "TargetListId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ApplyDeltaInput.prototype, "EntityName", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], ApplyDeltaInput.prototype, "ToAdd", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], ApplyDeltaInput.prototype, "ToRemove", void 0);
+__decorate([
+    Field(() => [String]),
+    __metadata("design:type", Array)
+], ApplyDeltaInput.prototype, "Unchanged", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ApplyDeltaInput.prototype, "AddCount", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ApplyDeltaInput.prototype, "RemoveCount", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ApplyDeltaInput.prototype, "UnchangedCount", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ApplyDeltaInput.prototype, "SourceTotal", void 0);
+__decorate([
+    Field(() => Int),
+    __metadata("design:type", Number)
+], ApplyDeltaInput.prototype, "TargetTotal", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ApplyDeltaInput.prototype, "DeltaToken", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], ApplyDeltaInput.prototype, "ConfirmDrops", void 0);
+ApplyDeltaInput = __decorate([
+    InputType('ApplyDeltaInput')
+], ApplyDeltaInput);
+export { ApplyDeltaInput };
+// ---------------------------------------------------------------------------
+// Sharing inputs / outputs (Phase 2)
+// ---------------------------------------------------------------------------
+let ShareTargetInput = class ShareTargetInput {
+};
+__decorate([
+    Field(() => String, { description: 'Target kind: user | role.' }),
+    __metadata("design:type", String)
+], ShareTargetInput.prototype, "Kind", void 0);
+__decorate([
+    Field(() => String, { nullable: true, description: 'User ID, required when Kind=user.' }),
+    __metadata("design:type", String)
+], ShareTargetInput.prototype, "UserID", void 0);
+__decorate([
+    Field(() => String, { nullable: true, description: 'Role ID, required when Kind=role.' }),
+    __metadata("design:type", String)
+], ShareTargetInput.prototype, "RoleID", void 0);
+ShareTargetInput = __decorate([
+    InputType('ShareTargetInput')
+], ShareTargetInput);
+export { ShareTargetInput };
+let ShareListInput = class ShareListInput {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ShareListInput.prototype, "ListID", void 0);
+__decorate([
+    Field(() => ShareTargetInput),
+    __metadata("design:type", ShareTargetInput)
+], ShareListInput.prototype, "Target", void 0);
+__decorate([
+    Field(() => String, { description: 'Permission level: View | Edit | Owner.' }),
+    __metadata("design:type", String)
+], ShareListInput.prototype, "PermissionLevel", void 0);
+ShareListInput = __decorate([
+    InputType('ShareListInput')
+], ShareListInput);
+export { ShareListInput };
+let InviteToListInput = class InviteToListInput {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], InviteToListInput.prototype, "ListID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], InviteToListInput.prototype, "Email", void 0);
+__decorate([
+    Field(() => String, { description: 'Role: Editor | Viewer.' }),
+    __metadata("design:type", String)
+], InviteToListInput.prototype, "Role", void 0);
+__decorate([
+    Field(() => Int, { nullable: true, description: 'Optional TTL in hours. Defaults to 7 days.' }),
+    __metadata("design:type", Number)
+], InviteToListInput.prototype, "TtlHours", void 0);
+InviteToListInput = __decorate([
+    InputType('InviteToListInput')
+], InviteToListInput);
+export { InviteToListInput };
+let ShareTargetType = class ShareTargetType {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ShareTargetType.prototype, "Kind", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ShareTargetType.prototype, "UserID", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ShareTargetType.prototype, "RoleID", void 0);
+ShareTargetType = __decorate([
+    ObjectType('ShareTargetType')
+], ShareTargetType);
+export { ShareTargetType };
+let ListShareSummaryType = class ListShareSummaryType {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListShareSummaryType.prototype, "PermissionID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListShareSummaryType.prototype, "ListID", void 0);
+__decorate([
+    Field(() => ShareTargetType),
+    __metadata("design:type", ShareTargetType)
+], ListShareSummaryType.prototype, "Target", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListShareSummaryType.prototype, "PermissionLevel", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ListShareSummaryType.prototype, "Status", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ListShareSummaryType.prototype, "SharedByUserID", void 0);
+__decorate([
+    Field(() => Date),
+    __metadata("design:type", Date)
+], ListShareSummaryType.prototype, "CreatedAt", void 0);
+ListShareSummaryType = __decorate([
+    ObjectType('ListShareSummaryType')
+], ListShareSummaryType);
+export { ListShareSummaryType };
+let SharedListSummaryType = class SharedListSummaryType {
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], SharedListSummaryType.prototype, "ListID", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], SharedListSummaryType.prototype, "ListName", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], SharedListSummaryType.prototype, "PermissionLevel", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], SharedListSummaryType.prototype, "SharedByUserID", void 0);
+__decorate([
+    Field(() => Date),
+    __metadata("design:type", Date)
+], SharedListSummaryType.prototype, "SharedAt", void 0);
+SharedListSummaryType = __decorate([
+    ObjectType('SharedListSummaryType')
+], SharedListSummaryType);
+export { SharedListSummaryType };
+let ShareResultType = class ShareResultType {
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], ShareResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ShareResultType.prototype, "ResultCode", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ShareResultType.prototype, "Message", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ShareResultType.prototype, "PermissionID", void 0);
+ShareResultType = __decorate([
+    ObjectType('ShareResultType')
+], ShareResultType);
+export { ShareResultType };
+let InviteResultType = class InviteResultType {
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], InviteResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], InviteResultType.prototype, "ResultCode", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], InviteResultType.prototype, "Message", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], InviteResultType.prototype, "InvitationID", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], InviteResultType.prototype, "Token", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], InviteResultType.prototype, "ExpiresAt", void 0);
+InviteResultType = __decorate([
+    ObjectType('InviteResultType')
+], InviteResultType);
+export { InviteResultType };
+let AcceptInvitationResultType = class AcceptInvitationResultType {
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], AcceptInvitationResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], AcceptInvitationResultType.prototype, "ResultCode", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], AcceptInvitationResultType.prototype, "Message", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], AcceptInvitationResultType.prototype, "PermissionID", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], AcceptInvitationResultType.prototype, "ListID", void 0);
+AcceptInvitationResultType = __decorate([
+    ObjectType('AcceptInvitationResultType')
+], AcceptInvitationResultType);
+export { AcceptInvitationResultType };
+let ComposeListsInput = class ComposeListsInput {
+};
+__decorate([
+    Field(() => String, { description: 'Set-op kind: union | intersection | difference.' }),
+    __metadata("design:type", String)
+], ComposeListsInput.prototype, "Op", void 0);
+__decorate([
+    Field(() => [ListSourceInput]),
+    __metadata("design:type", Array)
+], ComposeListsInput.prototype, "Inputs", void 0);
+__decorate([
+    Field(() => ListSourceInput, { nullable: true, description: 'Optional target list (for in-place set-op). Omit to preview against a new list.' }),
+    __metadata("design:type", ListSourceInput)
+], ComposeListsInput.prototype, "Target", void 0);
+ComposeListsInput = __decorate([
+    InputType('ComposeListsInput')
+], ComposeListsInput);
+export { ComposeListsInput };
+// ---------------------------------------------------------------------------
+// Boundary converters — exported for unit testing. Kept as standalone
+// functions (not methods) so tests don't have to construct a full
+// AppContext / type-graphql runtime.
+// ---------------------------------------------------------------------------
+export function toCoreSource(input) {
+    switch (input.Kind) {
+        case 'list':
+            if (!input.ListID)
+                throw new Error("ListSourceInput.ListID is required when Kind='list'");
+            return { kind: 'list', listId: input.ListID };
+        case 'view':
+            if (!input.ViewID)
+                throw new Error("ListSourceInput.ViewID is required when Kind='view'");
+            return { kind: 'view', viewId: input.ViewID };
+        case 'adhoc':
+            if (!input.EntityName || input.ExtraFilter == null) {
+                throw new Error("ListSourceInput.EntityName and ExtraFilter are required when Kind='adhoc'");
+            }
+            return { kind: 'adhoc', entityName: input.EntityName, extraFilter: input.ExtraFilter };
+        default:
+            throw new Error(`Unknown ListSourceInput.Kind: ${String(input.Kind)}`);
+    }
+}
+export function fromCoreDelta(delta) {
+    return {
+        TargetListId: delta.TargetListId,
+        EntityName: delta.EntityName,
+        ToAdd: delta.ToAdd,
+        ToRemove: delta.ToRemove,
+        Unchanged: delta.Unchanged,
+        Counts: { ...delta.Counts },
+        Warnings: delta.Warnings.map(fromCoreWarning),
+        DeltaToken: delta.DeltaToken,
+    };
+}
+export function fromCoreWarning(w) {
+    return {
+        Code: w.Code,
+        Message: w.Message,
+        DetailsJSON: w.Details ? JSON.stringify(w.Details) : undefined,
+    };
+}
+export function fromCoreApplyResult(r) {
+    return {
+        Success: r.Success,
+        ResultCode: r.ResultCode,
+        Message: r.Message,
+        CreatedListId: r.CreatedListId,
+        TargetListId: r.TargetListId,
+        AddedCount: r.Counts?.Added,
+        RemovedCount: r.Counts?.Removed,
+        FailedCount: r.Counts?.Failed,
+        Errors: r.Errors,
+    };
+}
+/** Convert a `ListShareSummary` from the core into the GraphQL DTO. */
+export function fromCoreShareSummary(s) {
+    return {
+        PermissionID: s.PermissionID,
+        ListID: s.ListID,
+        Target: s.Target.kind === 'user'
+            ? { Kind: 'user', UserID: s.Target.userId }
+            : { Kind: 'role', RoleID: s.Target.roleId },
+        PermissionLevel: s.PermissionLevel,
+        Status: s.Status,
+        SharedByUserID: s.SharedByUserID ?? undefined,
+        CreatedAt: s.CreatedAt,
+    };
+}
+/** Guard for required-when-Kind-X fields on discriminated inputs. */
+export function requireField(value, name) {
+    if (value == null)
+        throw new Error(`'${name}' is required`);
+    return value;
+}
+/** Three failure helpers — one per output type — keep the try/catch
+ *  sites in the resolver methods tiny. */
+export function shareUnexpected(e, op) {
+    const message = e instanceof Error ? e.message : String(e);
+    return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
+}
+export function inviteUnexpected(e, op) {
+    const message = e instanceof Error ? e.message : String(e);
+    return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
+}
+export function acceptInvitationUnexpected(e, op) {
+    const message = e instanceof Error ? e.message : String(e);
+    return { Success: false, ResultCode: 'UNEXPECTED_ERROR', Message: `${op}: ${message}` };
+}
+export function rebuildDeltaFromInput(input) {
+    return {
+        TargetListId: input.TargetListId,
+        EntityName: input.EntityName,
+        ToAdd: input.ToAdd,
+        ToRemove: input.ToRemove,
+        Unchanged: input.Unchanged,
+        Counts: {
+            Add: input.AddCount,
+            Remove: input.RemoveCount,
+            Unchanged: input.UnchangedCount,
+            SourceTotal: input.SourceTotal,
+            TargetTotal: input.TargetTotal,
+        },
+        Warnings: [],
+        DeltaToken: input.DeltaToken,
+    };
+}
+// ---------------------------------------------------------------------------
+// Resolver
+//
+// All public capability flows through one `ListOperations` instance per
+// request, constructed with the per-request read-write provider and the
+// authenticated user. Auth is enforced at two layers: this resolver checks
+// the user is authenticated (via UserPayload), and `ListOperations` itself
+// enforces the drop-guard / token / staleness contract.
+// ---------------------------------------------------------------------------
+let ListOperationsResolver = class ListOperationsResolver extends ResolverBase {
+    async PreviewListDelta(input, ctx) {
+        const ops = this.buildOps(ctx);
+        const source = toCoreSource(input.Source);
+        const target = input.Target === 'new' ? 'new' : { kind: 'list', listId: input.Target };
+        const delta = await ops.ComputeDelta(target, source, input.Mode);
+        return fromCoreDelta(delta);
+    }
+    async ApplyListDelta(input, ctx) {
+        const ops = this.buildOps(ctx);
+        try {
+            const delta = rebuildDeltaFromInput(input);
+            const result = await ops.ApplyDelta(delta, {
+                ConfirmDrops: input.ConfirmDrops,
+                DeltaToken: input.DeltaToken,
+            });
+            return fromCoreApplyResult(result);
+        }
+        catch (e) {
+            return this.unexpectedFailure(e, 'ApplyListDelta');
+        }
+    }
+    async MaterializeListFromView(viewId, options, ctx) {
+        const ops = this.buildOps(ctx);
+        try {
+            const opts = {
+                ListName: options.ListName,
+                CategoryId: options.CategoryId,
+                Description: options.Description,
+                RememberLineage: options.RememberLineage,
+                UseSnapshot: options.UseSnapshot,
+                RefreshMode: options.RefreshMode,
+            };
+            const result = await ops.MaterializeFromView(viewId, opts);
+            return fromCoreApplyResult(result);
+        }
+        catch (e) {
+            return this.unexpectedFailure(e, 'MaterializeListFromView');
+        }
+    }
+    async AddViewResultsToList(viewId, listId, ctx) {
+        const ops = this.buildOps(ctx);
+        try {
+            const result = await ops.AddViewResultsToList(viewId, listId);
+            return fromCoreApplyResult(result);
+        }
+        catch (e) {
+            return this.unexpectedFailure(e, 'AddViewResultsToList');
+        }
+    }
+    async RefreshListFromSource(listId, mode, confirmDrops, ctx) {
+        const ops = this.buildOps(ctx);
+        try {
+            const result = await ops.RefreshFromSource(listId, mode, { ConfirmDrops: confirmDrops });
+            return fromCoreApplyResult(result);
+        }
+        catch (e) {
+            return this.unexpectedFailure(e, 'RefreshListFromSource');
+        }
+    }
+    async ComposeLists(input, ctx) {
+        const ops = this.buildOps(ctx);
+        const inputs = input.Inputs.map(toCoreSource);
+        const target = input.Target ? toCoreSource(input.Target) : undefined;
+        const delta = await ops.ComputeSetOp(input.Op, inputs, target);
+        return fromCoreDelta(delta);
+    }
+    // -----------------------------------------------------------------------
+    // Sharing (Phase 2). Auth is enforced at two layers — this resolver checks
+    // the user is authenticated; `ListSharing` itself enforces the audit-log /
+    // status-transition contracts. Server-side notification dispatch fires
+    // automatically through the registered share-notification handler.
+    // -----------------------------------------------------------------------
+    async ShareList(input, ctx) {
+        const sharing = this.buildSharing(ctx);
+        try {
+            const target = input.Target.Kind === 'user'
+                ? { kind: 'user', userId: requireField(input.Target.UserID, 'Target.UserID') }
+                : { kind: 'role', roleId: requireField(input.Target.RoleID, 'Target.RoleID') };
+            const result = await sharing.Share({
+                ListID: input.ListID,
+                Target: target,
+                PermissionLevel: input.PermissionLevel,
+            });
+            return result;
+        }
+        catch (e) {
+            return shareUnexpected(e, 'ShareList');
+        }
+    }
+    async UnshareList(permissionId, ctx) {
+        const sharing = this.buildSharing(ctx);
+        try {
+            return await sharing.Unshare(permissionId);
+        }
+        catch (e) {
+            return shareUnexpected(e, 'UnshareList');
+        }
+    }
+    async InviteToList(input, ctx) {
+        const sharing = this.buildSharing(ctx);
+        try {
+            return await sharing.Invite({
+                ListID: input.ListID,
+                Email: input.Email,
+                Role: input.Role,
+                TtlMs: input.TtlHours != null ? input.TtlHours * 60 * 60 * 1000 : undefined,
+            });
+        }
+        catch (e) {
+            return inviteUnexpected(e, 'InviteToList');
+        }
+    }
+    async AcceptListInvitation(token, ctx) {
+        const sharing = this.buildSharing(ctx);
+        try {
+            return await sharing.AcceptInvitation(token);
+        }
+        catch (e) {
+            return acceptInvitationUnexpected(e, 'AcceptListInvitation');
+        }
+    }
+    async RevokeListInvitation(invitationId, ctx) {
+        const sharing = this.buildSharing(ctx);
+        try {
+            return await sharing.RevokeInvitation(invitationId);
+        }
+        catch (e) {
+            return shareUnexpected(e, 'RevokeListInvitation');
+        }
+    }
+    async ListSharesForList(listId, ctx) {
+        const sharing = this.buildSharing(ctx);
+        const shares = await sharing.GetSharesForList(listId);
+        return shares.map(fromCoreShareSummary);
+    }
+    async ListsSharedWithMe(ctx) {
+        const sharing = this.buildSharing(ctx);
+        const summaries = await sharing.GetListsSharedWithUser();
+        return summaries.map((s) => ({
+            ListID: s.ListID,
+            ListName: s.ListName,
+            PermissionLevel: s.PermissionLevel,
+            SharedByUserID: s.SharedByUserID ?? undefined,
+            SharedAt: s.SharedAt,
+        }));
+    }
+    // --- private helpers ---------------------------------------------------
+    buildSharing(ctx) {
+        const user = this.requireUser(ctx);
+        const provider = GetReadWriteProvider(ctx.providers, { allowFallbackToReadOnly: false });
+        return new ListSharing(user, provider);
+    }
+    buildOps(ctx) {
+        const user = this.requireUser(ctx);
+        const provider = GetReadWriteProvider(ctx.providers, { allowFallbackToReadOnly: false });
+        return new ListOperations(user, provider);
+    }
+    requireUser(ctx) {
+        const user = ctx.userPayload.userRecord;
+        if (!user)
+            throw new Error('User is not authenticated');
+        return user;
+    }
+    unexpectedFailure(e, op) {
+        const message = e instanceof Error ? e.message : String(e);
+        LogError(`${op} threw: ${message}`);
+        return {
+            Success: false,
+            ResultCode: 'UNEXPECTED_ERROR',
+            Message: message,
+        };
+    }
+};
+__decorate([
+    Query(() => ListDeltaType, {
+        description: 'Preview a list operation. Returns a signed DeltaToken that ApplyListDelta will accept (subject to TTL + drift checks).',
+    }),
+    __param(0, Arg('input', () => ComputeDeltaInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ComputeDeltaInput, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "PreviewListDelta", null);
+__decorate([
+    Mutation(() => ApplyListResultType, {
+        description: 'Apply a previously-previewed delta. Server enforces the drop-guard regardless of UI.',
+    }),
+    __param(0, Arg('input', () => ApplyDeltaInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ApplyDeltaInput, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "ApplyListDelta", null);
+__decorate([
+    Mutation(() => ApplyListResultType),
+    __param(0, Arg('viewId', () => String)),
+    __param(1, Arg('options', () => MaterializeOptionsInput)),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, MaterializeOptionsInput, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "MaterializeListFromView", null);
+__decorate([
+    Mutation(() => ApplyListResultType),
+    __param(0, Arg('viewId', () => String)),
+    __param(1, Arg('listId', () => String)),
+    __param(2, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "AddViewResultsToList", null);
+__decorate([
+    Mutation(() => ApplyListResultType),
+    __param(0, Arg('listId', () => String)),
+    __param(1, Arg('mode', () => String)),
+    __param(2, Arg('confirmDrops', () => Boolean)),
+    __param(3, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Boolean, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "RefreshListFromSource", null);
+__decorate([
+    Mutation(() => ListDeltaType, {
+        description: 'Preview a set-op (union / intersection / difference) across N sources, optionally projected into a target list.',
+    }),
+    __param(0, Arg('input', () => ComposeListsInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ComposeListsInput, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "ComposeLists", null);
+__decorate([
+    Mutation(() => ShareResultType),
+    __param(0, Arg('input', () => ShareListInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ShareListInput, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "ShareList", null);
+__decorate([
+    Mutation(() => ShareResultType),
+    __param(0, Arg('permissionId', () => String)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "UnshareList", null);
+__decorate([
+    Mutation(() => InviteResultType),
+    __param(0, Arg('input', () => InviteToListInput)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [InviteToListInput, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "InviteToList", null);
+__decorate([
+    Mutation(() => AcceptInvitationResultType),
+    __param(0, Arg('token', () => String)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "AcceptListInvitation", null);
+__decorate([
+    Mutation(() => ShareResultType),
+    __param(0, Arg('invitationId', () => String)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "RevokeListInvitation", null);
+__decorate([
+    Query(() => [ListShareSummaryType]),
+    __param(0, Arg('listId', () => String)),
+    __param(1, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "ListSharesForList", null);
+__decorate([
+    Query(() => [SharedListSummaryType]),
+    __param(0, Ctx()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ListOperationsResolver.prototype, "ListsSharedWithMe", null);
+ListOperationsResolver = __decorate([
+    Resolver()
+], ListOperationsResolver);
+export { ListOperationsResolver };
+export default ListOperationsResolver;
+//# sourceMappingURL=ListOperationsResolver.js.map