@better-giving/endowment 1.1.13 → 1.1.15

package/src/schema.mts

@@ -18,211 +18,178 @@ export {
   donateMethodId,
   donateMethodIds,
 };
-import {
-  url,
-  type InferInput,
-  type InferOutput,
-  array,
-  base64,
-  boolean,
-  check,
-  custom,
-  excludes,
-  filterItems,
-  integer,
-  isoTimestamp,
-  keyof,
-  lazy,
-  literal,
-  maxLength,
-  maxValue,
-  minLength,
-  minValue,
-  nonEmpty,
-  nullish,
-  number,
-  object,
-  omit,
-  optional,
-  partial,
-  picklist,
-  pipe,
-  regex,
-  startsWith,
-  string,
-  transform,
-  trim,
-  union,
-  uuid,
-} from "valibot";
-
-export const str = pipe(string(), trim());
-export const csv = lazy((x) => {
+import * as v from "valibot";
+
+export const str = v.pipe(v.string(), v.trim());
+export const csv = v.lazy((x) => {
   if (!x) return str;
-  return pipe(str, regex(/^[^,]+(?:,[^,]+)*$/, "invalid csv"));
+  return v.pipe(str, v.regex(/^[^,]+(?:,[^,]+)*$/, "invalid csv"));
 });
-export const csvStrs = pipe(
+export const csvStrs = v.pipe(
   csv,
-  transform((x) => x.split(",")),
-  filterItems((x) => x.length > 0)
+  v.transform((x) => x.split(",")),
+  v.filterItems((x) => x.length > 0)
 );
 
-const pct = pipe(number(), integer(), minValue(0), maxValue(100));
-export const allocation = pipe(
-  object({
+const pct = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(100));
+export const allocation = v.pipe(
+  v.object({
     cash: pct,
     liq: pct,
     lock: pct,
   }),
-  check((x) => x.cash + x.liq + x.lock === 100, "must total to 100")
+  v.check((x) => x.cash + x.liq + x.lock === 100, "must total to 100")
 );
 
-export interface Allocation extends InferOutput<typeof allocation> {}
+export interface Allocation extends v.InferOutput<typeof allocation> {}
 
-export const endowId = pipe(number(), integer(), minValue(1));
-export type EndowId = InferOutput<typeof endowId>;
-export const endowIdParam = pipe(
-  string(),
-  transform((x) => +x),
-  endowId
+export const int_id = v.pipe(v.number(), v.integer(), v.minValue(1));
+export type EndowId = v.InferOutput<typeof int_id>;
+export const endowIdParam = v.pipe(
+  v.string(),
+  v.transform((x) => +x),
+  int_id
 );
 
 export const segmentMaxChars = 30;
-export const segment = pipe(
+export const segment = v.pipe(
   str,
-  maxLength(
+  v.maxLength(
     segmentMaxChars,
     ({ requirement: r }) => `cannot exceed ${r} chars`
   ),
   //must not be id-like
-  regex(/^(?!^\d+$)/, "should not be an id"),
+  v.regex(/^(?!^\d+$)/, "should not be an id"),
   //valid characters
-  regex(/^[a-zA-Z0-9-._~]+$/, "allowed: numbers | letters | - | . | _ | ~"),
-  excludes("..", "should not contain double periods"),
-  custom((x) => !(x as string).startsWith("."), "should not start with dot"),
-  custom((x) => !(x as string).endsWith("."), "should not end with dot")
+  v.regex(/^[a-zA-Z0-9-._~]+$/, "allowed: numbers | letters | - | . | _ | ~"),
+  v.excludes("..", "should not contain double periods"),
+  v.custom((x) => !(x as string).startsWith("."), "should not start with dot"),
+  v.custom((x) => !(x as string).endsWith("."), "should not end with dot")
 );
 
-export const slug = lazy((x) => (x ? segment : str));
+export const slug = v.lazy((x) => (x ? segment : str));
 
-export const reg_number = pipe(
+export const reg_number = v.pipe(
   str,
-  nonEmpty("required"),
-  regex(/^[a-zA-Z0-9]+$/, "must only contain letters and numbers")
+  v.nonEmpty("required"),
+  v.regex(/^[a-zA-Z0-9]+$/, "must only contain letters and numbers")
 );
 
-export const _url = pipe(str, url());
+export const _url = v.pipe(str, v.url());
 
-export const httpsUrl = pipe(
+export const httpsUrl = v.pipe(
   str,
-  startsWith("https://", "should start with https://"),
-  custom((x) => x !== "https://", "incomplete url"),
-  url("invalid url")
+  v.startsWith("https://", "should start with https://"),
+  v.custom((x) => x !== "https://", "incomplete url"),
+  v.url("invalid url")
 );
 
-export const maybeEmptyHttpsUrl = lazy((x) => {
+export const maybeEmptyHttpsUrl = v.lazy((x) => {
   if (!x) return str;
   return httpsUrl;
 });
 
-export const social_media_urls = object({
-  facebook: optional(maybeEmptyHttpsUrl),
-  twitter: optional(maybeEmptyHttpsUrl),
-  linkedin: optional(maybeEmptyHttpsUrl),
-  discord: optional(maybeEmptyHttpsUrl),
-  instagram: optional(maybeEmptyHttpsUrl),
-  youtube: optional(maybeEmptyHttpsUrl),
-  tiktok: optional(maybeEmptyHttpsUrl),
+export const social_media_urls = v.object({
+  facebook: v.optional(maybeEmptyHttpsUrl),
+  twitter: v.optional(maybeEmptyHttpsUrl),
+  linkedin: v.optional(maybeEmptyHttpsUrl),
+  discord: v.optional(maybeEmptyHttpsUrl),
+  instagram: v.optional(maybeEmptyHttpsUrl),
+  youtube: v.optional(maybeEmptyHttpsUrl),
+  tiktok: v.optional(maybeEmptyHttpsUrl),
 });
 
 export interface SocialMediaURLs
-  extends InferOutput<typeof social_media_urls> {}
+  extends v.InferOutput<typeof social_media_urls> {}
 
 export const MAX_RECEIPT_MSG_CHAR = 500;
 
-export const incrementVal = pipe(
+export const incrementVal = v.pipe(
   str,
-  nonEmpty("required"),
-  transform((x) => +x),
-  number("must be a number"),
-  minValue(0, "must be greater than 0"),
+  v.nonEmpty("required"),
+  v.transform((x) => +x),
+  v.number("must be a number"),
+  v.minValue(0, "must be greater than 0"),
   //parsed output
-  transform((x) => x.toString())
+  v.transform((x) => x.toString())
 );
 
 export const MAX_NUM_INCREMENTS = 4;
 export const incrementLabelMaxChars = 60;
 export const taglineMaxChars = 140;
 
-export const incrementLabel = pipe(
+export const incrementLabel = v.pipe(
   str,
-  maxLength(
+  v.maxLength(
     incrementLabelMaxChars,
     ({ requirement: r }) => `cannot exceed ${r} characters`
   )
 );
 
-export const increment = object({
+export const increment = v.object({
   value: incrementVal,
   label: incrementLabel,
 });
 
-export interface Increment extends InferOutput<typeof increment> {}
+export interface Increment extends v.InferOutput<typeof increment> {}
 
-export const endowment = object({
-  id: endowId,
+export const endowment = v.object({
+  id: int_id,
   env,
-  slug: optional(slug),
+  slug: v.optional(slug),
   registration_number: reg_number,
-  name: pipe(str, nonEmpty("required")),
+  name: v.pipe(str, v.nonEmpty("required")),
   endow_designation: orgDesignation,
-  overview: optional(str),
-  tagline: optional(pipe(str, maxLength(taglineMaxChars))),
-  image: optional(_url),
-  logo: optional(_url),
-  card_img: optional(_url),
-  hq_country: pipe(str, nonEmpty("required")),
-  active_in_countries: pipe(array(str), nonEmpty("required")),
-  street_address: optional(str),
+  overview: v.optional(str),
+  tagline: v.optional(v.pipe(str, v.maxLength(taglineMaxChars))),
+  image: v.optional(_url),
+  logo: v.optional(_url),
+  card_img: v.optional(_url),
+  hq_country: v.pipe(str, v.nonEmpty("required")),
+  active_in_countries: v.pipe(v.array(str), v.nonEmpty("required")),
+  street_address: v.optional(str),
   social_media_urls,
   /** website */
-  url: optional(maybeEmptyHttpsUrl),
-  sdgs: pipe(array(unSdgNum), minLength(1)),
-  receiptMsg: optional(pipe(str, maxLength(MAX_RECEIPT_MSG_CHAR))),
+  url: v.optional(maybeEmptyHttpsUrl),
+  sdgs: v.pipe(v.array(unSdgNum), v.minLength(1)),
+  receiptMsg: v.optional(v.pipe(str, v.maxLength(MAX_RECEIPT_MSG_CHAR))),
   //can be optional, default false and need not be explicit
-  hide_bg_tip: optional(boolean()),
-  published: optional(boolean()),
+  hide_bg_tip: v.optional(v.boolean()),
+  published: v.optional(v.boolean()),
   /** allowed by default */
-  progDonationsAllowed: optional(boolean()),
-
-  allocation: optional(allocation),
-  donateMethods: optional(array(donateMethodId)),
-  increments: optional(pipe(array(increment), maxLength(MAX_NUM_INCREMENTS))),
-  fund_opt_in: optional(boolean()),
-  target: optional(
-    union([
-      literal("smart"),
+  progDonationsAllowed: v.optional(v.boolean()),
+
+  allocation: v.optional(allocation),
+  donateMethods: v.optional(v.array(donateMethodId)),
+  increments: v.optional(
+    v.pipe(v.array(increment), v.maxLength(MAX_NUM_INCREMENTS))
+  ),
+  fund_opt_in: v.optional(v.boolean()),
+  target: v.optional(
+    v.union([
+      v.literal("smart"),
       // "0" - none, `${number}` - fixed
-      pipe(
-        string(),
-        transform((v) => +v),
-        number(),
-        minValue(0),
-        transform((v) => v.toString())
+      v.pipe(
+        v.string(),
+        v.transform((v) => +v),
+        v.number(),
+        v.minValue(0),
+        v.transform((v) => v.toString())
       ),
     ])
   ),
   /** endowment is not claimed if `false` only */
-  claimed: boolean(),
-  kyc_donors_only: boolean(),
-  fiscal_sponsored: boolean(),
-  referral_id: optional(pipe(str, nonEmpty("required"))),
-  referrer: optional(pipe(str, nonEmpty("required"))),
-  referrer_expiry: optional(pipe(str, isoTimestamp())),
+  claimed: v.boolean(),
+  kyc_donors_only: v.boolean(),
+  fiscal_sponsored: v.boolean(),
+  referral_id: v.optional(v.pipe(str, v.nonEmpty("required"))),
+  referrer: v.optional(v.pipe(str, v.nonEmpty("required"))),
+  referrer_expiry: v.optional(v.pipe(str, v.isoTimestamp())),
+  w_form: v.optional(v.string()),
 });
 
-export const endowUpdate = partial(
-  omit(endowment, [
+export const endowUpdate = v.partial(
+  v.omit(endowment, [
     "id",
     "claimed",
     "kyc_donors_only",
@@ -231,98 +198,101 @@ export const endowUpdate = partial(
   ])
 );
 
-export const endowFields = keyof(endowment);
-export interface Endowment extends InferOutput<typeof endowment> {}
-export interface EndowUpdate extends InferOutput<typeof endowUpdate> {}
-export type EndowFields = InferOutput<typeof endowFields>;
+export const endowFields = v.keyof(endowment);
+export interface Endowment extends v.InferOutput<typeof endowment> {}
+export interface EndowUpdate extends v.InferOutput<typeof endowUpdate> {}
+export type EndowFields = v.InferOutput<typeof endowFields>;
 
 /** for ein path, only fields in reg-num/env gsi is available */
-export const endowQueryParams = object({
-  fields: optional(pipe(csvStrs, array(endowFields))),
+export const endowQueryParams = v.object({
+  fields: v.optional(v.pipe(csvStrs, v.array(endowFields))),
 });
 
-export interface EndowQueryParams extends InferInput<typeof endowQueryParams> {}
+export interface EndowQueryParams
+  extends v.InferInput<typeof endowQueryParams> {}
 
-const amnt = pipe(number(), minValue(0));
-export const programId = pipe(str, uuid());
-export type ProgramId = InferOutput<typeof programId>;
-export const milestoneId = pipe(str, uuid());
-export type MilestoneId = InferOutput<typeof milestoneId>;
+const amnt = v.pipe(v.number(), v.minValue(0));
+export const programId = v.pipe(str, v.uuid());
+export type ProgramId = v.InferOutput<typeof programId>;
+export const milestoneId = v.pipe(str, v.uuid());
+export type MilestoneId = v.InferOutput<typeof milestoneId>;
 
-export const newMilestone = object({
-  date: pipe(str, isoTimestamp()),
+export const newMilestone = v.object({
+  date: v.pipe(str, v.isoTimestamp()),
   title: str,
   description: str,
-  media: optional(_url),
+  media: v.optional(_url),
 });
 
-export const milestoneUpdate = partial(newMilestone, ["date"]);
-export interface MilestoneUpdate extends InferOutput<typeof milestoneUpdate> {}
+export const milestoneUpdate = v.partial(newMilestone, ["date"]);
+export interface MilestoneUpdate
+  extends v.InferOutput<typeof milestoneUpdate> {}
 
-export interface NewMilestone extends InferOutput<typeof newMilestone> {}
-export const milestone = object({ ...newMilestone.entries, id: milestoneId });
-export interface Milestone extends InferOutput<typeof milestone> {}
+export interface NewMilestone extends v.InferOutput<typeof newMilestone> {}
+export const milestone = v.object({ ...newMilestone.entries, id: milestoneId });
+export interface Milestone extends v.InferOutput<typeof milestone> {}
 
-export const newProgram = object({
+export const newProgram = v.object({
   title: str,
   description: str,
-  banner: optional(_url),
+  banner: v.optional(_url),
   /** null unsets target */
-  targetRaise: nullish(amnt),
-  milestones: pipe(array(newMilestone), maxLength(24)),
+  targetRaise: v.nullish(amnt),
+  milestones: v.pipe(v.array(newMilestone), v.maxLength(24)),
 });
 
-export const program = object({
-  ...omit(newProgram, ["milestones"]).entries,
+export const program = v.object({
+  ...v.omit(newProgram, ["milestones"]).entries,
   /** in USD */
-  totalDonations: optional(number()),
+  totalDonations: v.optional(v.number()),
   id: programId,
 });
 
-export const programUpdate = partial(omit(newProgram, ["milestones"]));
+export const programUpdate = v.partial(v.omit(newProgram, ["milestones"]));
 
-export interface NewProgram extends InferOutput<typeof newProgram> {}
-export interface Program extends InferOutput<typeof program> {}
-export interface ProgramUpdate extends InferOutput<typeof programUpdate> {}
+export interface NewProgram extends v.InferOutput<typeof newProgram> {}
+export interface Program extends v.InferOutput<typeof program> {}
+export interface ProgramUpdate extends v.InferOutput<typeof programUpdate> {}
 
-export const mediaUrl = pipe(str, url());
+export const mediaUrl = v.pipe(str, v.url());
 /**
  * so that media is automatically sorted by date
  * @see https://github.com/segmentio/ksuid
  * */
-export const mediaKsuid = pipe(str, nonEmpty() /** base62? */);
+export const mediaKsuid = v.pipe(str, v.nonEmpty() /** base62? */);
 export const mediaTypes = ["album", "article", "video"] as const;
-export const mediaType = picklist(mediaTypes);
-export type MediaType = InferOutput<typeof mediaType>;
+export const mediaType = v.picklist(mediaTypes);
+export type MediaType = v.InferOutput<typeof mediaType>;
 
-export const mediaUpdate = object({
-  url: optional(mediaUrl),
-  featured: optional(boolean()),
+export const mediaUpdate = v.object({
+  url: v.optional(mediaUrl),
+  featured: v.optional(v.boolean()),
 });
-export interface MediaUpdate extends InferOutput<typeof mediaUpdate> {}
+export interface MediaUpdate extends v.InferOutput<typeof mediaUpdate> {}
 
-export type MediaId = InferOutput<typeof mediaKsuid>;
+export type MediaId = v.InferOutput<typeof mediaKsuid>;
 
-export const mediaQueryParams = object({
-  type: optional(mediaType),
-  nextPageKey: optional(pipe(str, base64())),
-  featured: optional(
-    pipe(
+export const mediaQueryParams = v.object({
+  type: v.optional(mediaType),
+  nextPageKey: v.optional(v.pipe(str, v.base64())),
+  featured: v.optional(
+    v.pipe(
       str,
-      transform((x) => Boolean(x)),
-      boolean()
+      v.transform((x) => Boolean(x)),
+      v.boolean()
     )
   ),
-  limit: optional(
-    pipe(
-      string(),
-      transform((x) => +x),
-      number(),
-      integer(),
-      minValue(1)
+  limit: v.optional(
+    v.pipe(
+      v.string(),
+      v.transform((x) => +x),
+      v.number(),
+      v.integer(),
+      v.minValue(1)
     )
   ),
 });
-export interface MediaQueryParams extends InferInput<typeof mediaQueryParams> {}
+export interface MediaQueryParams
+  extends v.InferInput<typeof mediaQueryParams> {}
 export interface MediaQueryParamsObj
-  extends InferOutput<typeof mediaQueryParams> {}
+  extends v.InferOutput<typeof mediaQueryParams> {}