@plasius/schema 1.1.0 → 1.2.0

package/src/types.ts

@@ -1,156 +0,0 @@
-import FieldBuilder from "./field.builder.js";
-import { Infer } from "./infer.js";
-import { PII, PIIAction, PIIClassification, PIILogHandling } from "./pii.js";
-
-export type FieldTypeMap = {
-  string: string;
-  number: number;
-  boolean: boolean;
-  object: Record<string, unknown>;
-  "string[]": string[];
-  "number[]": number[];
-  "boolean[]": boolean[];
-  "object[]": Record<string, unknown>[];
-  ref: RefEntityId;
-  "ref[]": RefEntityId[];
-};
-
-export type FieldType = keyof FieldTypeMap;
-
-export type PIIEnforcement = "strict" | "warn" | "none";
-
-export interface SchemaOptions {
-  version?: string;
-  table?: string;
-  schemaValidator?: (value: any) => boolean;
-  piiEnforcement?: PIIEnforcement; // How should PII be enforced?
-}
-export type SchemaShape = Record<string, FieldBuilder<any>>;
-
-export interface FieldDefinition<T = unknown> {
-  type: FieldType;
-  __valueType?: T;
-  optional?: boolean;
-  immutable?: boolean;
-  description?: string;
-  refType?: string;
-  version?: string;
-  deprecated?: boolean;
-  deprecatedVersion?: string;
-  system?: boolean;
-  autoValidate?: boolean;
-  refPolicy?: "eager" | "lazy";
-  enum?: string[];
-  _shape?: SchemaShape;
-  pii?: PII;
-  validator?: (value: any) => boolean;
-}
-
-export interface ValidateCompositionOptions {
-  resolveEntity: (type: string, id: string) => Promise<any | null>;
-  validatorContext?: { visited: Set<string> };
-  maxDepth?: number;
-  log?: (msg: string) => void; // Optional for trace/debug
-  onlyFields?: string[]; // NEW
-}
-
-export interface Schema<T extends SchemaShape> {
-  //// The shape of the schema.
-  _shape: T;
-
-  //// System metadata about the schema
-  meta: { entityType: string; version: string };
-
-  //// Methods for schema validation
-  schemaValidator: (entity: Infer<T>) => boolean;
-
-  // Validate an input object against the schema
-  validate: (
-    input: unknown,
-    existing?: Record<string, any>
-  ) => ValidationResult<Infer<T>>;
-
-  // Validate an input object against the schema, with options for composition validation
-  validateComposition: (
-    entity: Infer<T>,
-    options: ValidateCompositionOptions
-  ) => Promise<void>;
-
-  //// Optional methods for schema metadata
-
-  // Get the tableName for this schema
-  tableName?: () => string | undefined; // Optional method to get the table name
-
-  //// 🔒 Optional methods for PII handling
-
-  // 🔒 Auto-prepare for read (decrypt PII)
-  prepareForRead(
-    stored: Record<string, any>,
-    decryptFn: (value: string) => any | null
-  ): Record<string, any>;
-
-  // 🔒 Auto-prepare for storage (encrypt/hash PII)
-  prepareForStorage(
-    input: Record<string, any>,
-    encryptFn: (value: any) => string,
-    hashFn: (value: any) => string
-  ): Record<string, any>;
-
-  // 🔒 Sanitize data for logging (e.g., redact PII)
-  sanitizeForLog(
-    data: Record<string, any>,
-    pseudonymFn: (value: any) => string
-  ): Record<string, any>;
-
-  // 🔒 Get PII audit information
-  getPiiAudit(): Array<{
-    field: string;
-    classification: PIIClassification;
-    action: PIIAction;
-    logHandling?: PIILogHandling;
-    purpose?: string;
-  }> | null;
-
-  // 🔒 Scrub PII for deletion (e.g., clear or hash sensitive data)
-  scrubPiiForDelete(stored: Record<string, any>): Record<string, any>;
-
-  describe(): {
-    entityType: string;
-    version: string;
-    shape: Record<
-      string,
-      {
-        type: FieldType;
-        optional: boolean;
-        immutable: boolean;
-        description: string;
-        version: string;
-        deprecated: boolean;
-        deprecatedVersion: string | null;
-        system: boolean;
-        enum: string[] | null;
-        refType: string | null;
-        pii: PII | null;
-      }
-    >;
-  };
-}
-
-export type DeepReadonly<T> = {
-  readonly [K in keyof T]: T[K] extends object
-    ? T[K] extends (...args: any[]) => any
-      ? T[K]
-      : DeepReadonly<T[K]>
-    : T[K];
-};
-
-export interface ValidationResult<T> {
-  valid: boolean;
-  value?: DeepReadonly<T>;
-  errors?: string[];
-}
-
-export type RefEntityId<T extends string = string> = {
-  type: T;
-  id: string;
-};

package/src/validation/countryCode.ISO3166.ts

@@ -1,256 +0,0 @@
-export const isoCountryCodes = new Set([
-  "AD",
-  "AE",
-  "AF",
-  "AG",
-  "AI",
-  "AL",
-  "AM",
-  "AO",
-  "AQ",
-  "AR",
-  "AS",
-  "AT",
-  "AU",
-  "AW",
-  "AX",
-  "AZ",
-  "BA",
-  "BB",
-  "BD",
-  "BE",
-  "BF",
-  "BG",
-  "BH",
-  "BI",
-  "BJ",
-  "BL",
-  "BM",
-  "BN",
-  "BO",
-  "BQ",
-  "BR",
-  "BS",
-  "BT",
-  "BV",
-  "BW",
-  "BY",
-  "BZ",
-  "CA",
-  "CC",
-  "CD",
-  "CF",
-  "CG",
-  "CH",
-  "CI",
-  "CK",
-  "CL",
-  "CM",
-  "CN",
-  "CO",
-  "CR",
-  "CU",
-  "CV",
-  "CW",
-  "CX",
-  "CY",
-  "CZ",
-  "DE",
-  "DJ",
-  "DK",
-  "DM",
-  "DO",
-  "DZ",
-  "EC",
-  "EE",
-  "EG",
-  "EH",
-  "ER",
-  "ES",
-  "ET",
-  "FI",
-  "FJ",
-  "FM",
-  "FO",
-  "FR",
-  "GA",
-  "GB",
-  "GD",
-  "GE",
-  "GF",
-  "GG",
-  "GH",
-  "GI",
-  "GL",
-  "GM",
-  "GN",
-  "GP",
-  "GQ",
-  "GR",
-  "GT",
-  "GU",
-  "GW",
-  "GY",
-  "HK",
-  "HM",
-  "HN",
-  "HR",
-  "HT",
-  "HU",
-  "ID",
-  "IE",
-  "IL",
-  "IM",
-  "IN",
-  "IO",
-  "IQ",
-  "IR",
-  "IS",
-  "IT",
-  "JE",
-  "JM",
-  "JO",
-  "JP",
-  "KE",
-  "KG",
-  "KH",
-  "KI",
-  "KM",
-  "KN",
-  "KP",
-  "KR",
-  "KW",
-  "KY",
-  "KZ",
-  "LA",
-  "LB",
-  "LC",
-  "LI",
-  "LK",
-  "LR",
-  "LS",
-  "LT",
-  "LU",
-  "LV",
-  "LY",
-  "MA",
-  "MC",
-  "MD",
-  "ME",
-  "MF",
-  "MG",
-  "MH",
-  "MK",
-  "ML",
-  "MM",
-  "MN",
-  "MO",
-  "MP",
-  "MQ",
-  "MR",
-  "MS",
-  "MT",
-  "MU",
-  "MV",
-  "MW",
-  "MX",
-  "MY",
-  "MZ",
-  "NA",
-  "NC",
-  "NE",
-  "NF",
-  "NG",
-  "NI",
-  "NL",
-  "NO",
-  "NP",
-  "NR",
-  "NU",
-  "NZ",
-  "OM",
-  "PA",
-  "PE",
-  "PF",
-  "PG",
-  "PH",
-  "PK",
-  "PL",
-  "PM",
-  "PN",
-  "PR",
-  "PT",
-  "PW",
-  "PY",
-  "QA",
-  "RE",
-  "RO",
-  "RS",
-  "RU",
-  "RW",
-  "SA",
-  "SB",
-  "SC",
-  "SD",
-  "SE",
-  "SG",
-  "SH",
-  "SI",
-  "SJ",
-  "SK",
-  "SL",
-  "SM",
-  "SN",
-  "SO",
-  "SR",
-  "SS",
-  "ST",
-  "SV",
-  "SX",
-  "SY",
-  "SZ",
-  "TC",
-  "TD",
-  "TF",
-  "TG",
-  "TH",
-  "TJ",
-  "TK",
-  "TL",
-  "TM",
-  "TN",
-  "TO",
-  "TR",
-  "TT",
-  "TV",
-  "TZ",
-  "UA",
-  "UG",
-  "UM",
-  "US",
-  "UY",
-  "UZ",
-  "VA",
-  "VC",
-  "VE",
-  "VG",
-  "VI",
-  "VN",
-  "VU",
-  "WF",
-  "WS",
-  "YE",
-  "YT",
-  "ZA",
-  "ZM",
-  "ZW",
-]);
-
-/**
- * Validates whether a string is a valid ISO 3166-1 alpha-2 country code. 
- * Performs a case-insensitive lookup against a predefined set of known codes.
- */
-export const validateCountryCode = (value: unknown): boolean => {
-  if (typeof value !== "string") return false;
-  return isoCountryCodes.has(value.toUpperCase());
-};

package/src/validation/currencyCode.ISO4217.ts

@@ -1,191 +0,0 @@
-export const isoCurrencyCodes = new Set([
-  "AED",
-  "AFN",
-  "ALL",
-  "AMD",
-  "ANG",
-  "AOA",
-  "ARS",
-  "AUD",
-  "AWG",
-  "AZN",
-  "BAM",
-  "BBD",
-  "BDT",
-  "BGN",
-  "BHD",
-  "BIF",
-  "BMD",
-  "BND",
-  "BOB",
-  "BOV",
-  "BRL",
-  "BSD",
-  "BTN",
-  "BWP",
-  "BYN",
-  "BZD",
-  "CAD",
-  "CDF",
-  "CHE",
-  "CHF",
-  "CHW",
-  "CLF",
-  "CLP",
-  "CNY",
-  "COP",
-  "COU",
-  "CRC",
-  "CUC",
-  "CUP",
-  "CVE",
-  "CZK",
-  "DJF",
-  "DKK",
-  "DOP",
-  "DZD",
-  "EGP",
-  "ERN",
-  "ETB",
-  "EUR",
-  "FJD",
-  "FKP",
-  "GBP",
-  "GEL",
-  "GHS",
-  "GIP",
-  "GMD",
-  "GNF",
-  "GTQ",
-  "GYD",
-  "HKD",
-  "HNL",
-  "HRK",
-  "HTG",
-  "HUF",
-  "IDR",
-  "ILS",
-  "INR",
-  "IQD",
-  "IRR",
-  "ISK",
-  "JMD",
-  "JOD",
-  "JPY",
-  "KES",
-  "KGS",
-  "KHR",
-  "KMF",
-  "KPW",
-  "KRW",
-  "KWD",
-  "KYD",
-  "KZT",
-  "LAK",
-  "LBP",
-  "LKR",
-  "LRD",
-  "LSL",
-  "LYD",
-  "MAD",
-  "MDL",
-  "MGA",
-  "MKD",
-  "MMK",
-  "MNT",
-  "MOP",
-  "MRU",
-  "MUR",
-  "MVR",
-  "MWK",
-  "MXN",
-  "MXV",
-  "MYR",
-  "MZN",
-  "NAD",
-  "NGN",
-  "NIO",
-  "NOK",
-  "NPR",
-  "NZD",
-  "OMR",
-  "PAB",
-  "PEN",
-  "PGK",
-  "PHP",
-  "PKR",
-  "PLN",
-  "PYG",
-  "QAR",
-  "RON",
-  "RSD",
-  "RUB",
-  "RWF",
-  "SAR",
-  "SBD",
-  "SCR",
-  "SDG",
-  "SEK",
-  "SGD",
-  "SHP",
-  "SLL",
-  "SOS",
-  "SRD",
-  "SSP",
-  "STN",
-  "SVC",
-  "SYP",
-  "SZL",
-  "THB",
-  "TJS",
-  "TMT",
-  "TND",
-  "TOP",
-  "TRY",
-  "TTD",
-  "TWD",
-  "TZS",
-  "UAH",
-  "UGX",
-  "USD",
-  "USN",
-  "UYI",
-  "UYU",
-  "UYW",
-  "UZS",
-  "VES",
-  "VND",
-  "VUV",
-  "WST",
-  "XAF",
-  "XAG",
-  "XAU",
-  "XBA",
-  "XBB",
-  "XBC",
-  "XBD",
-  "XCD",
-  "XDR",
-  "XOF",
-  "XPD",
-  "XPF",
-  "XPT",
-  "XSU",
-  "XTS",
-  "XUA",
-  "XXX",
-  "YER",
-  "ZAR",
-  "ZMW",
-  "ZWL",
-]);
-
-
-/** 
- * Validates whether a string is a valid ISO 4217 currency code. 
- * Performs a case-insensitive lookup against a predefined set of known codes.
- */
-export const validateCurrencyCode = (value: unknown): boolean => {
-  if (typeof value !== "string") return false;
-  return isoCurrencyCodes.has(value.toUpperCase());
-};

package/src/validation/dateTime.ISO8601.ts

@@ -1,60 +0,0 @@
-/**
- * Validates whether a string is a properly formatted ISO 8601 datetime, date, or time.
- * 
- * @param value - The value to validate.
- * @param options - Optional settings for validation mode.
- * @param options.mode - The mode of validation:
- *   - "datetime" (default): Checks full ISO 8601 datetime and equality with toISOString().
- *   - "date": Validates that the string is in YYYY-MM-DD format and represents a valid date.
- *   - "time": Validates that the string matches a valid HH:MM:SS(.sss)?Z? ISO 8601 time pattern.
- * @returns True if the value is valid according to the specified mode; otherwise, false.
- */
-export const validateDateTimeISO = (
-  value: unknown,
-  options?: { mode?: "datetime" | "date" | "time" }
-): boolean => {
-  const mode = options?.mode ?? "datetime";
-
-  if (typeof value !== "string") return false;
-
-  if (mode === "datetime") {
-    // Strict ISO 8601 date-time: YYYY-MM-DDTHH:mm:ss(.fraction)?(Z|±HH:MM)
-    const isoDateTimeRegex =
-      /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
-
-    if (!isoDateTimeRegex.test(value)) return false;
-
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) return false;
-
-    // We purposely do NOT require `value === date.toISOString()` because
-    // valid ISO8601 inputs may include offsets (e.g., "+01:00") or omit
-    // milliseconds, both of which produce a different canonical ISO string.
-    // The regex ensures strict shape; Date parsing ensures it is a real moment.
-    return true;
-  }
-
-  if (mode === "date") {
-    // YYYY-MM-DD format
-    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-    if (!dateRegex.test(value)) return false;
-    const date = new Date(value);
-    if (isNaN(date.getTime())) return false;
-    // Ensure the date parts match exactly (to avoid 2023-02-30 being accepted)
-    const [year, month, day] = value.split("-").map(Number);
-    return (
-      date.getUTCFullYear() === year &&
-      date.getUTCMonth() + 1 === month &&
-      date.getUTCDate() === day
-    );
-  }
-
-  if (mode === "time") {
-    // HH:MM:SS(.sss)?Z?
-    // Hours: 00-23, Minutes: 00-59, Seconds: 00-59, optional fractional seconds, optional Z
-    const timeRegex = /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(\.\d+)?Z?$/;
-    return timeRegex.test(value);
-  }
-
-  return false;
-};

package/src/validation/email.RFC5322.ts

@@ -1,9 +0,0 @@
-/**
- * Validates an email string using a simplified RFC 5322-compliant regex.
- * Returns true if the input is a string in the format `name@domain.tld`.
- */
-export const validateEmail = (value: unknown): boolean => {
-  if (typeof value !== "string") return false;
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(value);
-};

package/src/validation/generalText.OWASP.ts

@@ -1,39 +0,0 @@
-/**
- * Validates that a text field is safe for storage (per OWASP guidelines).
- * Applies to general text fields: names, descriptions, titles, etc.
- * Global Standard: OWASP Input Validation Cheat Sheet (2024)
- */
-export function validateSafeText(value: unknown): boolean {
-  if (typeof value !== "string") return false;
-
-  // Trimmed version should not be empty
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return false;
-
-  // Reject control chars
-  for (let i = 0; i < trimmed.length; i++) {
-    const code = trimmed.codePointAt(i);
-    if (code !== undefined && (code >= 0x00 && code <= 0x1F || code === 0x7F)) {
-      return false;
-    }
-  }
-
-  // Reject dangerous characters
-  if (/['"<>\\{}();]/.test(trimmed)) return false;
-
-  // Reject SQL-style injection patterns
-  if (
-    /(--|\b(SELECT|UPDATE|DELETE|INSERT|DROP|ALTER|EXEC|UNION|GRANT|REVOKE)\b|\/\*|\*\/|@@)/i.test(
-      trimmed
-    )
-  )
-    return false;
-
-  // Reject null char
-  if (trimmed.includes("\u0000")) return false;
-
-  // Optional: limit length
-  if (trimmed.length > 1024) return false;
-
-  return true;
-}