@m1212e/rumble 0.26.4 → 0.27.0

package/out/index.d.mts

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import { One, SQL, Table } from "drizzle-orm";
 import { GraphQLError, GraphQLScalarType, GraphQLSchema } from "graphql";
 import { Tracer } from "@opentelemetry/api";
@@ -9,6 +8,7 @@ import { PgAsyncDatabase } from "drizzle-orm/pg-core";
 import { MySqlAsyncDatabase } from "drizzle-orm/mysql-core";
 import { SQLiteAsyncDatabase } from "drizzle-orm/sqlite-core";
 import SchemaBuilder from "@pothos/core";
+import { z } from "zod";
 import { PhoneNumber } from "libphonenumber-js";
 import { IncomingMessage, RequestListener, ServerResponse } from "node:http";
 import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
@@ -450,41 +450,6 @@ export declare const assertFirstEntryExists: <T>(value: T[]) => T;
  */
 export declare function mapNullFieldsToUndefined<T extends object>(obj: T): { [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null>; };
 //#endregion
-//#region lib/scalars/address.d.ts
-/**
- * The shape of a postal address, modeled after the OIDC `address` claim
- * (https://openid.net/specs/openid-connect-core-1_0.html#AddressClaim) and schema.org's
- * `PostalAddress`.
- */
-type AddressShape = {
-  /** The street address, which may be multiple lines separated by newlines. */
-  streetAddress?: string | null;
-  /** City or town. */
-  locality?: string | null;
-  /** State, province, prefecture or region. */
-  region?: string | null;
-  /** Postal or zip code. */
-  postalCode?: string | null;
-  /** ISO 3166-1 alpha-2 country code. */
-  countryCode?: string | null;
-};
-/**
- * AddressInput's shape differs from AddressShape in that `countryCode` and `streetAddress` are
- * required. `countryCode`: without a country there is nothing for the validator to check
- * requiredness/format/region against, so a country-less "address" can't be verified as valid
- * for anywhere. `streetAddress`: checked against every one of the 252 countries in
- * libaddressinput's dataset — it is the one field required in literally all of them (unlike
- * e.g. city, which 13 countries including Japan and Singapore don't require, or state/zip,
- * required in barely a sixth to a third of countries) — so it's safe to require unconditionally
- * rather than only per-country. The remaining fields stay optional since their requiredness
- * genuinely varies by country; that's enforced dynamically by `addressValidationSchema` instead
- * of statically here.
- */
-type AddressInputShape = Omit<AddressShape, "countryCode" | "streetAddress"> & {
-  countryCode: string;
-  streetAddress: string;
-};
-//#endregion
 //#region lib/args/whereArgsImplementer.d.ts
 type NumberWhereInputArgument = {
   eq?: number;
@@ -5253,6 +5218,148 @@ export declare const rumble: <UserContext extends Record<string, any>, DB extend
   buildSchema: () => GraphQLSchema;
 };
 //#endregion
+//#region lib/scalars/address.d.ts
+/**
+ * The shape of a postal address, modeled after the OIDC `address` claim
+ * (https://openid.net/specs/openid-connect-core-1_0.html#AddressClaim) and schema.org's
+ * `PostalAddress`.
+ */
+type AddressShape = {
+  /** The street address, which may be multiple lines separated by newlines. */
+  streetAddress?: string | null;
+  /** City or town. */
+  locality?: string | null;
+  /** State, province, prefecture or region. */
+  region?: string | null;
+  /** Postal or zip code. */
+  postalCode?: string | null;
+  /** ISO 3166-1 alpha-2 country code. */
+  countryCode?: string | null;
+};
+/**
+ * AddressInput's shape differs from AddressShape in that `countryCode` and `streetAddress` are
+ * required. `countryCode`: without a country there is nothing for the validator to check
+ * requiredness/format/region against, so a country-less "address" can't be verified as valid
+ * for anywhere. `streetAddress`: checked against every one of the 252 countries in
+ * libaddressinput's dataset — it is the one field required in literally all of them (unlike
+ * e.g. city, which 13 countries including Japan and Singapore don't require, or state/zip,
+ * required in barely a sixth to a third of countries) — so it's safe to require unconditionally
+ * rather than only per-country. The remaining fields stay optional since their requiredness
+ * genuinely varies by country; that's enforced dynamically by `addressValidationSchema` instead
+ * of statically here.
+ */
+type AddressInputShape = Omit<AddressShape, "countryCode" | "streetAddress"> & {
+  countryCode: string;
+  streetAddress: string;
+};
+//#endregion
+//#region lib/scalars/addressData.d.ts
+type RegionAddressRules = {
+  /** Regex the postal code must start with. */
+  zip?: string;
+  /** Example postal code within the region. */
+  zipex?: string;
+  /** Other names the region is known by, e.g. "California" for CA. */
+  names?: string[];
+};
+type CountryAddressRules = {
+  /** One-letter codes of the required fields, see the libaddressinput metadata docs. */
+  require: string;
+  /** Regex the whole postal code must match. */
+  zip?: string;
+  /** Example postal code. */
+  zipex?: string;
+  /** Regions by their upper-cased code. */
+  regions?: Record<string, RegionAddressRules>;
+};
+/*! Address data derived from Google's Address Data Service (https://github.com/google/libaddressinput),
+ * licensed under CC-BY 4.0 (https://creativecommons.org/licenses/by/4.0/).
+ * Changes: reduced to required fields, postal code patterns and examples, and regions with
+ * their names, with region codes upper-cased and ISO 3166-2 ids used where available. */
+export declare const addressData: Record<string, CountryAddressRules>;
+//#endregion
+//#region lib/scalars/addressValidation.d.ts
+type AddressIssue = {
+  path: keyof AddressShape;
+  message: string;
+};
+type NormalizedAddress = {
+  streetAddress: string | null;
+  locality: string | null;
+  region: string | null;
+  postalCode: string | null;
+  countryCode: string;
+};
+/**
+ * One rule an address is checked against, e.g. `checkPostalCode`. It only runs for countries
+ * that have rules, and returns an empty array when the address passes.
+ */
+type AddressCheck = (args: {
+  address: NormalizedAddress;
+  rules: CountryAddressRules;
+}) => AddressIssue[];
+/** Flags fields the country requires but the address leaves empty. */
+export declare const checkRequiredFields: AddressCheck;
+/**
+ * Flags a region that isn't in the country's region list. Countries without a list accept any
+ * region. Expects the region already resolved by `normalizeAddress`.
+ */
+export declare const checkRegion: AddressCheck;
+/**
+ * Flags a postal code that doesn't match the country's format, or doesn't belong to the given
+ * region (e.g. a Washington ZIP code for California). An empty postal code passes, since
+ * `checkRequiredFields` covers that.
+ */
+export declare const checkPostalCode: AddressCheck;
+/** The checks `validateAddress` runs, in order. */
+export declare const addressChecks: AddressCheck[];
+/**
+ * Resolves a region code or any of its names, in any case, to the region code, e.g. "california"
+ * to "CA" for the US. Returns undefined for unknown regions and countries without a region list.
+ */
+export declare function findRegionCode({ countryCode, region }: {
+  countryCode: string;
+  region: string;
+}): string | undefined;
+/**
+ * Fixes the unambiguous, purely-cosmetic issues (stray surrounding whitespace, wrong case)
+ * instead of rejecting an address over them. Run it before `validateAddress`, which expects
+ * its output.
+ *
+ * `countryCode` and `postalCode` are uppercased since their canonical forms always are (ISO
+ * 3166-1 codes, and postal codes in every country that mixes letters and digits, e.g. GB/CA/NL).
+ * A region that matches a known region code or name, like "california" in the US, is replaced
+ * by its code. Any other region and the locality are only trimmed, since they're free text.
+ */
+export declare function normalizeAddress(address: AddressShape): NormalizedAddress;
+/**
+ * Checks a normalized address against its country's rules and returns every issue found, or an
+ * empty array for a valid address.
+ *
+ * @example
+ * ```ts
+ * const issues = validateAddress(normalizeAddress(input));
+ * ```
+ */
+export declare function validateAddress(address: NormalizedAddress): AddressIssue[];
+/**
+ * The schema `AddressInput` validates with. It normalizes the address, so parsing returns the
+ * corrected value, and reports every issue on its field.
+ */
+export declare const addressValidationSchema: z.ZodPipe<z.ZodObject<{
+  streetAddress: z.ZodString;
+  locality: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  postalCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  countryCode: z.ZodString;
+}, z.core.$strip>, z.ZodTransform<NormalizedAddress, {
+  streetAddress: string;
+  locality?: string | null | undefined;
+  region?: string | null | undefined;
+  postalCode?: string | null | undefined;
+  countryCode: string;
+}>>;
+//#endregion
 //#region lib/scalars/emailAddress.d.ts
 /**
  * Validates an email address using graphql-scalars' own format check, then lowercases it, exactly
@@ -5298,4 +5405,5 @@ export declare class RumbleError extends Error {
  */
 export declare class RumbleErrorSafe extends GraphQLError {}
 //#endregion
+export type { AddressCheck, AddressInputShape, AddressIssue, AddressShape, CountryAddressRules, NormalizedAddress, RegionAddressRules };
 //# sourceMappingURL=index.d.mts.map