@btst/plugin-affiliate 0.0.0-stage → 1.0.0

package/dist/query-keys.d.ts

@@ -0,0 +1,394 @@
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
+import { ResourceClient } from '@btst/stack/plugins/client';
+import { CreateAffiliateInput, UpdateAffiliateInput, ListParams, ListResult, Affiliate, AffiliateStats, AffiliatePortal, Commission, Payout, CreatePayoutInput } from './types.js';
+
+type AffiliateApplicationInput = Omit<CreateAffiliateInput, "userId">;
+type AffiliatePortalInput = Pick<UpdateAffiliateInput, "name" | "email" | "code" | "payoutDetails">;
+/** Shared declarations keep client hooks and server query consumers on the same keys. */
+declare const affiliateResources: {
+    affiliates: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => ListResult<Affiliate>;
+            };
+            detail: {
+                path: string;
+                params: (id: string, _partition?: unknown) => {
+                    id: string;
+                };
+                select: (data: unknown) => {
+                    affiliate: Affiliate;
+                    stats: AffiliateStats;
+                };
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (body: CreateAffiliateInput) => {
+                    body: CreateAffiliateInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, data }: {
+                    id: string;
+                    data: UpdateAffiliateInput;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: UpdateAffiliateInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    affiliatePortal: {
+        queries: {
+            detail: {
+                path: string;
+                key: (partition?: unknown) => unknown[];
+                select: (data: unknown) => AffiliatePortal;
+            };
+        };
+        mutations: {
+            apply: {
+                path: string;
+                method: "POST";
+                input: (body: AffiliateApplicationInput) => {
+                    body: AffiliateApplicationInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (body: AffiliatePortalInput) => {
+                    body: AffiliatePortalInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    affiliateCommissions: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => ListResult<Commission>;
+            };
+        };
+        mutations: {
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, status, }: {
+                    id: string;
+                    status: "approved" | "voided";
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        status: "approved" | "voided";
+                    };
+                };
+                select: (data: unknown) => Commission;
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    affiliatePayouts: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => ListResult<Payout>;
+            };
+            export: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => {
+                    csv: string;
+                };
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (body: CreatePayoutInput) => {
+                    body: CreatePayoutInput;
+                };
+                select: (data: unknown) => Payout;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, ...body }: {
+                    id: string;
+                    status: "sent" | "failed";
+                    reference?: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        status: "sent" | "failed";
+                        reference?: string;
+                    };
+                };
+                select: (data: unknown) => Payout;
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+};
+declare function createAffiliateQueryKeys(client: ResourceClient, headers?: HeadersInit): _btst_stack_plugins_client.ResourceQueryKeys<{
+    affiliates: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => ListResult<Affiliate>;
+            };
+            detail: {
+                path: string;
+                params: (id: string, _partition?: unknown) => {
+                    id: string;
+                };
+                select: (data: unknown) => {
+                    affiliate: Affiliate;
+                    stats: AffiliateStats;
+                };
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (body: CreateAffiliateInput) => {
+                    body: CreateAffiliateInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, data }: {
+                    id: string;
+                    data: UpdateAffiliateInput;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: UpdateAffiliateInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    affiliatePortal: {
+        queries: {
+            detail: {
+                path: string;
+                key: (partition?: unknown) => unknown[];
+                select: (data: unknown) => AffiliatePortal;
+            };
+        };
+        mutations: {
+            apply: {
+                path: string;
+                method: "POST";
+                input: (body: AffiliateApplicationInput) => {
+                    body: AffiliateApplicationInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (body: AffiliatePortalInput) => {
+                    body: AffiliatePortalInput;
+                };
+                select: (data: unknown) => Affiliate;
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    affiliateCommissions: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => ListResult<Commission>;
+            };
+        };
+        mutations: {
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, status, }: {
+                    id: string;
+                    status: "approved" | "voided";
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        status: "approved" | "voided";
+                    };
+                };
+                select: (data: unknown) => Commission;
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    affiliatePayouts: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => ListResult<Payout>;
+            };
+            export: {
+                path: string;
+                query: (params?: ListParams, _partition?: unknown) => {
+                    limit?: number;
+                    offset?: number;
+                    affiliateId?: string;
+                    status?: string;
+                    currency?: string;
+                };
+                select: (data: unknown) => {
+                    csv: string;
+                };
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (body: CreatePayoutInput) => {
+                    body: CreatePayoutInput;
+                };
+                select: (data: unknown) => Payout;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, ...body }: {
+                    id: string;
+                    status: "sent" | "failed";
+                    reference?: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        status: "sent" | "failed";
+                        reference?: string;
+                    };
+                };
+                select: (data: unknown) => Payout;
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+}>;
+
+export { affiliateResources, createAffiliateQueryKeys };
+export type { AffiliateApplicationInput, AffiliatePortalInput };

package/dist/query-keys.mjs

@@ -0,0 +1,149 @@
+import { createResourceQueryKeys } from '@btst/stack/plugins/client';
+
+const invalidates = [
+  "affiliates",
+  "affiliatePortal",
+  "affiliateCommissions",
+  "affiliatePayouts"
+];
+const affiliateResources = {
+  affiliates: {
+    queries: {
+      list: {
+        path: "/affiliate/affiliates",
+        query: (params = {}, _partition) => ({
+          ...params
+        }),
+        select: (data) => data
+      },
+      detail: {
+        path: "/affiliate/affiliates/:id",
+        params: (id, _partition) => ({ id }),
+        select: (data) => data
+      }
+    },
+    mutations: {
+      create: {
+        path: "@post/affiliate/affiliates",
+        method: "POST",
+        input: (body) => ({ body }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      },
+      update: {
+        path: "@put/affiliate/affiliates/:id",
+        method: "PUT",
+        input: ({ id, data }) => ({
+          params: { id },
+          body: data
+        }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      },
+      delete: {
+        path: "@delete/affiliate/affiliates/:id",
+        method: "DELETE",
+        input: (id) => ({ params: { id } }),
+        invalidates,
+        refresh: false
+      }
+    }
+  },
+  affiliatePortal: {
+    queries: {
+      detail: {
+        path: "/affiliate/portal",
+        key: (partition) => [partition],
+        select: (data) => data
+      }
+    },
+    mutations: {
+      apply: {
+        path: "@post/affiliate/apply",
+        method: "POST",
+        input: (body) => ({ body }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      },
+      update: {
+        path: "@put/affiliate/portal",
+        method: "PUT",
+        input: (body) => ({ body }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      }
+    }
+  },
+  affiliateCommissions: {
+    queries: {
+      list: {
+        path: "/affiliate/commissions",
+        query: (params = {}, _partition) => ({
+          ...params
+        }),
+        select: (data) => data
+      }
+    },
+    mutations: {
+      update: {
+        path: "@put/affiliate/commissions/:id",
+        method: "PUT",
+        input: ({
+          id,
+          status
+        }) => ({ params: { id }, body: { status } }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      }
+    }
+  },
+  affiliatePayouts: {
+    queries: {
+      list: {
+        path: "/affiliate/payouts",
+        query: (params = {}, _partition) => ({
+          ...params
+        }),
+        select: (data) => data
+      },
+      export: {
+        path: "/affiliate/payouts/export",
+        query: (params = {}, _partition) => ({
+          ...params
+        }),
+        select: (data) => data
+      }
+    },
+    mutations: {
+      create: {
+        path: "@post/affiliate/payouts",
+        method: "POST",
+        input: (body) => ({ body }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      },
+      update: {
+        path: "@put/affiliate/payouts/:id",
+        method: "PUT",
+        input: ({
+          id,
+          ...body
+        }) => ({ params: { id }, body }),
+        select: (data) => data,
+        invalidates,
+        refresh: false
+      }
+    }
+  }
+};
+function createAffiliateQueryKeys(client, headers) {
+  return createResourceQueryKeys(client, affiliateResources, headers);
+}
+
+export { affiliateResources, createAffiliateQueryKeys };

package/dist/schemas.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+const zod = require('zod');
+
+const affiliateCodeSchema = zod.z.string().trim().min(3).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+const moneySchema = zod.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const currencySchema = zod.z.string().regex(/^[A-Z]{3}$/);
+const affiliateStatusSchema = zod.z.enum([
+  "pending",
+  "approved",
+  "suspended"
+]);
+const commissionTypeSchema = zod.z.enum(["percent", "flat"]);
+zod.z.enum([
+  "pending",
+  "approved",
+  "paid",
+  "voided"
+]);
+zod.z.enum(["pending", "sent", "failed"]);
+const idSchema = zod.z.object({ id: zod.z.string().min(1) });
+const listSchema = zod.z.object({
+  limit: zod.z.coerce.number().int().min(1).max(100).optional(),
+  offset: zod.z.coerce.number().int().nonnegative().optional(),
+  affiliateId: zod.z.string().min(1).optional(),
+  status: zod.z.string().optional(),
+  currency: currencySchema.optional()
+});
+const affiliateListSchema = listSchema.pick({ limit: true, offset: true, status: true }).extend({ status: affiliateStatusSchema.optional() });
+const applicationSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(200),
+  email: zod.z.email().max(320),
+  code: affiliateCodeSchema.optional(),
+  payoutDetails: zod.z.string().max(1e4).optional()
+});
+const createAffiliateSchema = applicationSchema.extend({
+  userId: zod.z.string().min(1)
+});
+const updateAffiliateSchema = applicationSchema.partial().extend({
+  payoutDetails: zod.z.string().max(1e4).nullable().optional(),
+  status: affiliateStatusSchema.optional(),
+  notes: zod.z.string().max(1e4).nullable().optional(),
+  commissionType: commissionTypeSchema.nullable().optional(),
+  commissionValue: zod.z.number().finite().nonnegative().nullable().optional()
+});
+const updatePortalSchema = applicationSchema.partial().extend({ payoutDetails: zod.z.string().max(1e4).nullable().optional() });
+const trackClickSchema = zod.z.object({
+  code: affiliateCodeSchema,
+  landingPath: zod.z.string().max(2048).optional(),
+  referrer: zod.z.string().max(2048).optional(),
+  ipHash: zod.z.string().max(256).optional(),
+  userAgent: zod.z.string().max(2048).optional()
+});
+const createConversionSchema = zod.z.object({
+  externalRef: zod.z.string().min(1).max(255).optional(),
+  amount: moneySchema,
+  currency: currencySchema.default("USD"),
+  attribution: zod.z.object({
+    code: affiliateCodeSchema.optional(),
+    clickId: zod.z.string().min(1).optional()
+  }).refine(
+    (v) => v.code || v.clickId,
+    "Attribution requires a code or click ID"
+  ).optional()
+});
+const updateCommissionSchema = zod.z.object({
+  status: zod.z.enum(["approved", "voided"])
+});
+const createPayoutSchema = zod.z.object({
+  affiliateId: zod.z.string().min(1),
+  currency: currencySchema,
+  commissionIds: zod.z.array(zod.z.string().min(1)).min(1).max(1e3).optional()
+});
+const updatePayoutSchema = zod.z.object({
+  status: zod.z.enum(["sent", "failed"]),
+  reference: zod.z.string().max(1e3).optional()
+});
+
+exports.affiliateCodeSchema = affiliateCodeSchema;
+exports.affiliateListSchema = affiliateListSchema;
+exports.affiliateStatusSchema = affiliateStatusSchema;
+exports.applicationSchema = applicationSchema;
+exports.commissionTypeSchema = commissionTypeSchema;
+exports.createAffiliateSchema = createAffiliateSchema;
+exports.createConversionSchema = createConversionSchema;
+exports.createPayoutSchema = createPayoutSchema;
+exports.currencySchema = currencySchema;
+exports.idSchema = idSchema;
+exports.listSchema = listSchema;
+exports.moneySchema = moneySchema;
+exports.trackClickSchema = trackClickSchema;
+exports.updateAffiliateSchema = updateAffiliateSchema;
+exports.updateCommissionSchema = updateCommissionSchema;
+exports.updatePayoutSchema = updatePayoutSchema;
+exports.updatePortalSchema = updatePortalSchema;