@railway-ts/pipelines 0.1.0

package/dist/schema/index.mjs

@@ -0,0 +1,735 @@
+// src/result/result.ts
+var RESULT_BRAND = Symbol("RESULT_BRAND");
+function ok(value) {
+  return {
+    ok: true,
+    value,
+    [RESULT_BRAND]: "ok"
+  };
+}
+function err(error) {
+  return { ok: false, error, [RESULT_BRAND]: "error" };
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+function mapErr(result, fn) {
+  return result.ok ? result : err(fn(result.error));
+}
+function match(result, patterns) {
+  if (isOk(result)) {
+    const okFn = patterns.ok;
+    return okFn(result.value);
+  } else {
+    const errFn = patterns.err;
+    return errFn(result.error);
+  }
+}
+function fromTry(f) {
+  try {
+    return ok(f());
+  } catch (error) {
+    return err(error instanceof Error ? error.message : String(error));
+  }
+}
+
+// src/schema/core.ts
+function object(schema, { strict = true } = {}) {
+  return (obj, parentPath = []) => {
+    if (obj === null || typeof obj !== "object") {
+      return err([{ path: parentPath, message: "Expected an object" }]);
+    }
+    const allErrors = [];
+    const validatedObj = {};
+    if (strict !== false) {
+      const extraKeys = Object.keys(obj).filter((key) => !Object.prototype.hasOwnProperty.call(schema, key));
+      if (extraKeys.length > 0) {
+        for (const key of extraKeys) {
+          allErrors.push({
+            path: [...parentPath, key],
+            message: `Unexpected field: '${key}'`
+          });
+        }
+      }
+    }
+    for (const key in schema) {
+      if (!Object.prototype.hasOwnProperty.call(schema, key)) continue;
+      const validator = schema[key];
+      if (!validator) continue;
+      const value = obj[key];
+      const fieldPath = [...parentPath, key];
+      const result = validator(value, fieldPath);
+      if (isOk(result)) {
+        validatedObj[key] = result.value;
+      } else {
+        allErrors.push(...result.error);
+      }
+    }
+    if (allErrors.length > 0) {
+      return err(allErrors);
+    }
+    return ok(validatedObj);
+  };
+}
+function required(validator, message = "Field is required") {
+  return (value, path = []) => {
+    if (value === void 0 || value === null) {
+      return err([{ path, message }]);
+    }
+    return validator(value, path);
+  };
+}
+function optional(validator) {
+  return (value, path = []) => {
+    if (value === void 0 || value === null) {
+      return ok(void 0);
+    }
+    return validator(value, path);
+  };
+}
+function nullable(message = "Must be null") {
+  return (value, path = []) => {
+    if (value !== null) {
+      return err([{ path, message }]);
+    }
+    return ok(null);
+  };
+}
+function emptyAsOptional(validator) {
+  return (value, path = []) => {
+    if (value === "" || Array.isArray(value) && value.length === 0 || typeof value === "object" && value !== null && Object.keys(value).length === 0) {
+      return ok(void 0);
+    }
+    return optional(validator)(value, path);
+  };
+}
+function literal(expectedValue, message = `Value must be '${String(expectedValue)}'`) {
+  return (value, path = []) => {
+    if (value !== expectedValue) {
+      return err([{ path, message }]);
+    }
+    return ok(expectedValue);
+  };
+}
+
+// src/schema/utils.ts
+function chain(...validators) {
+  return (value, path = []) => {
+    let result = ok(value);
+    for (const validator of validators) {
+      if (isErr(result)) return result;
+      const nextResult = validator(result.value, path);
+      result = isErr(nextResult) ? nextResult : ok(nextResult.value);
+    }
+    return result;
+  };
+}
+function validate(value, validator, path = []) {
+  return validator(value, path);
+}
+function formatErrors(errors) {
+  return errors.reduce(
+    (acc, error) => {
+      const formattedPath = error.path.reduce((path, segment, index) => {
+        if (/^\d+$/.test(segment)) {
+          return `${path}[${segment}]`;
+        } else {
+          return index === 0 ? segment : `${path}.${segment}`;
+        }
+      }, "");
+      acc[formattedPath] = error.message;
+      return acc;
+    },
+    {}
+  );
+}
+function validateAndFormatResult(input, schema) {
+  const result = validate(input, schema);
+  return match(result, {
+    ok: (data) => ({ valid: true, data }),
+    err: (errors) => ({ valid: false, errors: formatErrors(errors) })
+  });
+}
+function transform(transformer) {
+  return (value) => ok(transformer(value));
+}
+function refine(predicate, message = "Custom validation failed") {
+  return (value, path = []) => {
+    if (!predicate(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+
+// src/schema/string.ts
+function string(message = "Must be a string") {
+  return (value, path = []) => {
+    if (typeof value !== "string") {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function minLength(min2, message = `Must be at least ${min2} characters`) {
+  return (value, path = []) => {
+    if (value.length < min2) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function maxLength(max2, message = `Must be at most ${max2} characters`) {
+  return (value, path = []) => {
+    if (value.length > max2) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function pattern(regex, message = "Invalid format") {
+  return (value, path = []) => {
+    if (!regex.test(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function nonEmpty(message = "String must not be empty") {
+  return (value, path = []) => {
+    if (value.trim().length === 0) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function email(message = "Invalid email format") {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return pattern(emailRegex, message);
+}
+function phoneNumber(message = "Invalid phone number format") {
+  const phoneRegex = /^\+?[\d\s\-()]{8,20}$/;
+  return (value, path = []) => {
+    const cleanedValue = value.replaceAll(/\s+/g, "");
+    if (!phoneRegex.test(cleanedValue)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+
+// src/schema/array.ts
+function array(itemValidator) {
+  return (value, parentPath = []) => {
+    if (!Array.isArray(value)) {
+      return err([{ path: parentPath, message: "Expected an array" }]);
+    }
+    const allErrors = [];
+    const validatedItems = [];
+    for (const [i, item] of value.entries()) {
+      const itemPath = [...parentPath, i.toString()];
+      const result = itemValidator(item, itemPath);
+      if (isOk(result)) {
+        validatedItems.push(result.value);
+      } else {
+        allErrors.push(...result.error);
+      }
+    }
+    if (allErrors.length > 0) {
+      return err(allErrors);
+    }
+    return ok(validatedItems);
+  };
+}
+function minItems(min2, message = `Array must have at least ${min2} items`) {
+  return (value, path = []) => {
+    if (value.length < min2) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function maxItems(max2, message = `Array must have at most ${max2} items`) {
+  return (value, path = []) => {
+    if (value.length > max2) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function notEmpty(message = "Array must not be empty") {
+  return minItems(1, message);
+}
+function unique(message = "Array must contain unique values", keyExtractor) {
+  return (value, path = []) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [i, item] of value.entries()) {
+      const key = keyExtractor ? keyExtractor(item) : item;
+      if (seen.has(key)) {
+        return err([
+          {
+            path: [...path, i.toString()],
+            message
+          }
+        ]);
+      }
+      seen.add(key);
+    }
+    return ok(value);
+  };
+}
+function oneOf(allowedValues, message = `Value must be one of: ${allowedValues.join(", ")}`) {
+  return (value, path = []) => {
+    if (!allowedValues.includes(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function stringEnum(allowedValues, message = `Value must be one of: ${allowedValues.join(", ")}`) {
+  return chain(string("Value must be a string"), (value, path = []) => {
+    if (!allowedValues.includes(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  });
+}
+
+// src/schema/number.ts
+function number(message = "Must be a number") {
+  return (value, path = []) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function min(value, message = `Must be at least ${value}`) {
+  return (input, path = []) => {
+    if (input < value) {
+      return err([{ path, message }]);
+    }
+    return ok(input);
+  };
+}
+function max(value, message = `Must be at most ${value}`) {
+  return (input, path = []) => {
+    if (input > value) {
+      return err([{ path, message }]);
+    }
+    return ok(input);
+  };
+}
+function between(min2, max2, message = `Must be between ${min2} and ${max2}`) {
+  return (input, path = []) => {
+    if (input < min2 || input > max2) {
+      return err([{ path, message }]);
+    }
+    return ok(input);
+  };
+}
+function integer(message = "Must be an integer") {
+  return (value, path = []) => {
+    if (!Number.isInteger(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function positive(message = "Must be a positive number") {
+  return (value, path = []) => {
+    if (value <= 0) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function negative(message = "Must be a negative number") {
+  return (value, path = []) => {
+    if (value >= 0) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function nonZero(message = "Must not be zero") {
+  return (value, path = []) => {
+    if (value === 0) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function divisibleBy(divisor, message = `Must be divisible by ${divisor}`) {
+  return (value, path = []) => {
+    if (value % divisor !== 0) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function precision(maxDecimalPlaces, message = `Must have at most ${maxDecimalPlaces} decimal places`) {
+  return (value, path = []) => {
+    const str = value.toString();
+    const decimalPlaces = (str.split(".")[1] || "").length;
+    if (decimalPlaces > maxDecimalPlaces) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function finite(message = "Must be a finite number") {
+  return (value, path = []) => {
+    if (!Number.isFinite(value)) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+
+// src/schema/parsers.ts
+function parseNumber(message = "Must be a valid number") {
+  return (value, path = []) => {
+    if (typeof value === "number") {
+      return ok(value);
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed === "") {
+        return err([{ path, message }]);
+      }
+      const num = Number(trimmed);
+      if (!Number.isNaN(num)) {
+        return ok(num);
+      }
+    }
+    return err([{ path, message }]);
+  };
+}
+function parseBigInt(message = "Must be a valid BigInt") {
+  return (value, path = []) => {
+    if (typeof value === "bigint") {
+      return ok(value);
+    }
+    if (typeof value === "string" || typeof value === "number") {
+      try {
+        if (typeof value === "number" && !Number.isInteger(value)) {
+          return err([
+            {
+              path,
+              message: "Cannot convert non-integer number to BigInt"
+            }
+          ]);
+        }
+        const bigIntValue = BigInt(value);
+        return ok(bigIntValue);
+      } catch {
+        return err([{ path, message }]);
+      }
+    }
+    return err([{ path, message }]);
+  };
+}
+function parseEnum(enumObject, message = `Must be a valid enum value`) {
+  return (value, path = []) => {
+    const enumEntries = Object.entries(enumObject).filter(
+      ([key]) => Number.isNaN(Number(key)) || !Number.isInteger(Number(key))
+    );
+    const enumValues = enumEntries.map(([, val]) => val);
+    if (enumValues.includes(value)) {
+      return ok(value);
+    }
+    if (typeof value === "string") {
+      const parsed = Number(value);
+      if (!Number.isNaN(parsed) && enumValues.includes(parsed)) {
+        return ok(parsed);
+      }
+      const exactEntry = enumEntries.find(([key]) => key === value);
+      if (exactEntry) {
+        return ok(exactEntry[1]);
+      }
+      const lowerValue = value.toLowerCase();
+      const caseInsensitiveEntry = enumEntries.find(([key]) => key.toLowerCase() === lowerValue);
+      if (caseInsensitiveEntry) {
+        return ok(caseInsensitiveEntry[1]);
+      }
+    }
+    return err([
+      {
+        path,
+        message
+      }
+    ]);
+  };
+}
+function parseDate(message = "Must be a valid date") {
+  return (value, path = []) => {
+    if (value instanceof Date) {
+      return ok(value);
+    }
+    let dateValue;
+    if (typeof value === "string") {
+      dateValue = new Date(value);
+    } else if (typeof value === "number") {
+      dateValue = new Date(value);
+    } else {
+      return err([{ path, message }]);
+    }
+    if (Number.isNaN(dateValue.getTime())) {
+      return err([{ path, message }]);
+    }
+    return ok(dateValue);
+  };
+}
+function parseBool(message = "Must be a valid boolean value") {
+  return (value, path = []) => {
+    if (typeof value === "boolean") {
+      return ok(value);
+    }
+    if (typeof value === "string") {
+      const normalized = value.toLowerCase().trim();
+      if (normalized === "true" || normalized === "1" || normalized === "yes") {
+        return ok(true);
+      }
+      if (normalized === "false" || normalized === "0" || normalized === "no") {
+        return ok(false);
+      }
+    }
+    if (typeof value === "number") {
+      if (value === 1) return ok(true);
+      if (value === 0) return ok(false);
+    }
+    return err([{ path, message }]);
+  };
+}
+function parseString(message = "Must be convertible to string") {
+  return (value, path = []) => {
+    if (typeof value === "string") {
+      return ok(value);
+    }
+    if (value === null || value === void 0) {
+      return err([{ path, message }]);
+    }
+    return ok(String(value));
+  };
+}
+function parseJSON(message = "Must be valid JSON") {
+  return (value, path = []) => {
+    if (typeof value === "string") {
+      return mapErr(
+        fromTry(() => JSON.parse(value)),
+        () => [{ path, message }]
+      );
+    }
+    if (typeof value === "object" && value !== null) {
+      return ok(value);
+    }
+    return err([{ path, message }]);
+  };
+}
+function parseISODate(message = "Must be a valid ISO date string") {
+  return (value, path = []) => {
+    if (typeof value !== "string") {
+      return err([{ path, message }]);
+    }
+    if (!/^\d{4}-\d{2}-\d{2}/.test(value)) {
+      return err([{ path, message }]);
+    }
+    const date2 = new Date(value);
+    if (Number.isNaN(date2.getTime())) {
+      return err([{ path, message }]);
+    }
+    const originalMonth = value.slice(5, 7);
+    const originalDay = value.slice(8, 10);
+    const parsedMonth = String(date2.getUTCMonth() + 1).padStart(2, "0");
+    const parsedDay = String(date2.getUTCDate()).padStart(2, "0");
+    if (originalMonth !== parsedMonth || originalDay !== parsedDay) {
+      return err([{ path, message }]);
+    }
+    return ok(date2);
+  };
+}
+function parseURL(message = "Must be a valid URL") {
+  return (value, path = []) => {
+    if (typeof value !== "string") {
+      return err([{ path, message }]);
+    }
+    try {
+      return ok(new URL(value));
+    } catch {
+      return err([{ path, message }]);
+    }
+  };
+}
+
+// src/schema/date.ts
+function date(message = "Must be a Date object") {
+  return (value, path = []) => {
+    if (!(value instanceof Date)) {
+      return err([{ path, message }]);
+    }
+    if (Number.isNaN(value.getTime())) {
+      return err([
+        {
+          path,
+          message: "Invalid Date"
+        }
+      ]);
+    }
+    return ok(value);
+  };
+}
+function dateRange(min2, max2, message = `Must be between ${min2.toISOString().split("T")[0]} and ${max2.toISOString().split("T")[0]}`) {
+  return (value, path = []) => {
+    if (value < min2 || value > max2) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function pastDate(message = "Must be a date in the past") {
+  return (value, path = []) => {
+    if (value >= /* @__PURE__ */ new Date()) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function futureDate(message = "Must be a date in the future") {
+  return (value, path = []) => {
+    if (value <= /* @__PURE__ */ new Date()) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function todayOrFuture(message = "Must be today or a future date") {
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  return (value, path = []) => {
+    if (value < today) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+
+// src/schema/boolean.ts
+function boolean(message = "Must be a boolean") {
+  return (value, path = []) => {
+    if (typeof value !== "boolean") {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+function matches(expected, message = `Value must be ${expected}`) {
+  return (value, path = []) => {
+    if (value !== expected) {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+
+// src/schema/union.ts
+function union(validators, options) {
+  const { collectAllErrors = true, errorPrefix } = options || {};
+  return (value, parentPath = []) => {
+    if (validators.length === 0) {
+      return err([{ path: parentPath, message: "No validators provided to union" }]);
+    }
+    const allErrors = [];
+    for (const validator of validators) {
+      const result = validator(value, parentPath);
+      if (isOk(result)) {
+        return result;
+      }
+      allErrors.push(result.error);
+      if (!collectAllErrors) {
+        break;
+      }
+    }
+    const combinedErrors = allErrors.flat().map((error) => ({
+      path: error.path,
+      message: errorPrefix ? `${errorPrefix}: ${error.message}` : error.message
+    }));
+    return err(combinedErrors);
+  };
+}
+function discriminatedUnion(discriminantField, validatorMap, fallbackMessage = `Invalid discriminant value for '${discriminantField}'`) {
+  return (value, parentPath = []) => {
+    if (value === null || typeof value !== "object") {
+      return err([{ path: parentPath, message: "Expected an object" }]);
+    }
+    const discriminantValue = value[discriminantField];
+    if (typeof discriminantValue !== "string") {
+      return err([
+        {
+          path: [...parentPath, discriminantField],
+          message: `Missing or invalid discriminant field '${discriminantField}'`
+        }
+      ]);
+    }
+    const validator = validatorMap[discriminantValue];
+    if (!validator) {
+      return err([
+        {
+          path: [...parentPath, discriminantField],
+          message: `${fallbackMessage}: '${discriminantValue}'`
+        }
+      ]);
+    }
+    return validator(value, parentPath);
+  };
+}
+function withCommonFields(commonSchema, specificSchema) {
+  return (value, path = []) => {
+    const commonResult = commonSchema(value, path);
+    if (isErr(commonResult)) {
+      return commonResult;
+    }
+    const specificResult = specificSchema(value, path);
+    if (isErr(specificResult)) {
+      return specificResult;
+    }
+    const combinedValue = {
+      ...commonResult.value,
+      ...specificResult.value
+    };
+    return ok(combinedValue);
+  };
+}
+
+// src/schema/enum.ts
+function enumValue(enumObject, message, excludedValues) {
+  return (value, path = []) => {
+    const enumValues = Object.values(enumObject);
+    if (!enumValues.includes(value)) {
+      const defaultMessage = `Value must be one of: ${enumValues.join(", ")}`;
+      return err([{ path, message: message || defaultMessage }]);
+    }
+    if (excludedValues && excludedValues.includes(value)) {
+      const defaultMessage = `Selected value is excluded from valid enum values`;
+      return err([{ path, message: `${message || defaultMessage}` }]);
+    }
+    return ok(value);
+  };
+}
+
+// src/schema/bigint.ts
+function bigint(message = "Must be a bigint") {
+  return (value, path = []) => {
+    if (typeof value !== "bigint") {
+      return err([{ path, message }]);
+    }
+    return ok(value);
+  };
+}
+
+export { array, between, bigint, boolean, chain, date, dateRange, discriminatedUnion, divisibleBy, email, emptyAsOptional, enumValue, finite, formatErrors, futureDate, integer, literal, matches, max, maxItems, maxLength, min, minItems, minLength, negative, nonEmpty, nonZero, notEmpty, nullable, number, object, oneOf, optional, parseBigInt, parseBool, parseDate, parseEnum, parseISODate, parseJSON, parseNumber, parseString, parseURL, pastDate, pattern, phoneNumber, positive, precision, refine, required, string, stringEnum, todayOrFuture, transform, union, unique, validate, validateAndFormatResult, withCommonFields };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map