@awsless/validate 0.0.21 → 0.0.23

package/dist/index.cjs

@@ -22,8 +22,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   bigfloat: () => bigfloat,
-  bigint: () => bigint2,
-  date: () => date,
   duration: () => duration,
   dynamoDbStream: () => dynamoDbStream,
   json: () => json,
@@ -42,16 +40,21 @@ __reExport(index_exports, require("valibot"), module.exports);
 // src/schema/json.ts
 var import_json = require("@awsless/json");
 var import_valibot = require("valibot");
-var json = (schema) => {
-  return (0, import_valibot.transform)(
-    (0, import_valibot.string)(),
-    (value) => {
+var json = (schema, message = "Invalid JSON") => {
+  return (0, import_valibot.pipe)(
+    (0, import_valibot.string)(message),
+    (0, import_valibot.rawTransform)((ctx) => {
+      let result;
       try {
-        return (0, import_json.parse)(value);
-      } catch (error) {
-        return null;
+        result = (0, import_json.parse)(ctx.dataset.value);
+      } catch (_error) {
+        ctx.addIssue({
+          message
+        });
+        return ctx.NEVER;
       }
-    },
+      return result;
+    }),
     schema
   );
 };
@@ -59,193 +62,173 @@ var json = (schema) => {
 // src/schema/bigfloat.ts
 var import_big_float = require("@awsless/big-float");
 var import_valibot2 = require("valibot");
-var make = (value) => new import_big_float.BigFloat(value);
-function bigfloat(arg1, arg2) {
-  const [msg, pipe] = (0, import_valibot2.defaultArgs)(arg1, arg2);
-  const error = msg ?? "Invalid bigfloat";
+function bigfloat(message = "Invalid bigfloat") {
   return (0, import_valibot2.union)(
     [
-      (0, import_valibot2.instance)(import_big_float.BigFloat, pipe),
-      (0, import_valibot2.transform)((0, import_valibot2.string)([(0, import_valibot2.custom)((input) => input !== "" && !isNaN(Number(input)), error)]), make, pipe),
-      (0, import_valibot2.transform)((0, import_valibot2.number)(), make, pipe),
-      (0, import_valibot2.transform)(
-        (0, import_valibot2.object)({
-          exponent: (0, import_valibot2.number)(),
-          coefficient: (0, import_valibot2.bigint)()
-        }),
-        make,
-        pipe
-      )
-    ],
-    error
-  );
-}
-
-// src/schema/bigint.ts
-var import_valibot3 = require("valibot");
-function bigint2(arg1, arg2) {
-  const [error, pipe] = (0, import_valibot3.defaultArgs)(arg1, arg2);
-  return (0, import_valibot3.union)(
-    [
-      (0, import_valibot3.bigint)(pipe),
-      (0, import_valibot3.transform)(
-        (0, import_valibot3.string)([(0, import_valibot3.regex)(/^-?[0-9]+$/)]),
-        (input) => {
-          return BigInt(input);
-        },
-        (0, import_valibot3.bigint)(pipe)
-      )
-    ],
-    error ?? "Invalid BigInt"
-  );
-}
-
-// src/schema/date.ts
-var import_valibot4 = require("valibot");
-function date(arg1, arg2) {
-  const [error, pipe] = (0, import_valibot4.defaultArgs)(arg1, arg2);
-  return (0, import_valibot4.union)(
-    [
-      (0, import_valibot4.date)(pipe),
-      (0, import_valibot4.transform)(
-        (0, import_valibot4.string)(),
-        (input) => {
-          return new Date(input);
-        },
-        (0, import_valibot4.date)(pipe)
+      (0, import_valibot2.instance)(import_big_float.BigFloat),
+      (0, import_valibot2.pipe)(
+        (0, import_valibot2.string)(),
+        (0, import_valibot2.decimal)(),
+        (0, import_valibot2.transform)((v) => (0, import_big_float.parse)(v))
+      ),
+      (0, import_valibot2.pipe)(
+        (0, import_valibot2.bigint)(),
+        (0, import_valibot2.transform)((v) => (0, import_big_float.parse)(v))
+      ),
+      (0, import_valibot2.pipe)(
+        (0, import_valibot2.number)(),
+        (0, import_valibot2.transform)((v) => (0, import_big_float.parse)(v))
       )
     ],
-    error ?? "Invalid date"
+    message
   );
 }
 
 // src/schema/uuid.ts
-var import_valibot5 = require("valibot");
-var uuid = (error) => {
-  return (0, import_valibot5.string)(error ?? "Invalid UUID", [(0, import_valibot5.uuid)()]);
+var import_valibot3 = require("valibot");
+var uuid = (message = "Invalid UUID") => {
+  return (0, import_valibot3.pipe)((0, import_valibot3.string)(message), (0, import_valibot3.uuid)(message));
 };
 
 // src/schema/duration.ts
 var import_duration = require("@awsless/duration");
-var import_valibot6 = require("valibot");
-function duration(arg1, arg2) {
-  const [msg, pipe] = (0, import_valibot6.defaultArgs)(arg1, arg2);
-  const error = msg ?? "Invalid duration";
-  return (0, import_valibot6.instance)(import_duration.Duration, error, pipe);
+var import_valibot4 = require("valibot");
+function duration(message = "Invalid duration") {
+  return (0, import_valibot4.instance)(import_duration.Duration, message);
 }
 
 // src/schema/aws/sqs-queue.ts
-var import_valibot7 = require("valibot");
-var sqsQueue = (body) => {
-  const schema = body ?? (0, import_valibot7.unknown)();
-  return (0, import_valibot7.union)(
+var import_valibot5 = require("valibot");
+var sqsQueue = (schema, message = "Invalid SQS Queue payload") => {
+  return (0, import_valibot5.union)(
     [
-      (0, import_valibot7.transform)(schema, (input) => [input]),
-      (0, import_valibot7.array)(schema),
-      (0, import_valibot7.transform)(
-        (0, import_valibot7.object)({
-          Records: (0, import_valibot7.array)(
-            (0, import_valibot7.object)({
+      // Prioritize the expected payload during production
+      (0, import_valibot5.pipe)(
+        (0, import_valibot5.object)({
+          Records: (0, import_valibot5.array)(
+            (0, import_valibot5.object)({
               body: json(schema)
             })
           )
         }),
-        (input) => input.Records.map((record) => {
-          return record.body;
-        })
-      )
+        (0, import_valibot5.transform)((v) => v.Records.map((r) => r.body))
+      ),
+      // These are allowed during testing
+      (0, import_valibot5.pipe)(
+        schema,
+        (0, import_valibot5.transform)((v) => [v])
+      ),
+      (0, import_valibot5.array)(schema)
     ],
-    "Invalid SQS Queue input"
+    message
   );
 };
 
 // src/schema/aws/sns-topic.ts
-var import_valibot8 = require("valibot");
-var snsTopic = (body) => {
-  const schema = body ?? (0, import_valibot8.unknown)();
-  return (0, import_valibot8.union)(
+var import_valibot6 = require("valibot");
+var snsTopic = (schema, message = "Invalid SNS Topic payload") => {
+  return (0, import_valibot6.union)(
     [
-      (0, import_valibot8.transform)(schema, (input) => [input]),
-      (0, import_valibot8.array)(schema),
-      (0, import_valibot8.transform)(
-        (0, import_valibot8.object)({
-          Records: (0, import_valibot8.array)(
-            (0, import_valibot8.object)({
-              Sns: (0, import_valibot8.object)({
+      (0, import_valibot6.pipe)(
+        schema,
+        (0, import_valibot6.transform)((v) => [v])
+      ),
+      (0, import_valibot6.array)(schema),
+      (0, import_valibot6.pipe)(
+        (0, import_valibot6.object)({
+          Records: (0, import_valibot6.array)(
+            (0, import_valibot6.object)({
+              Sns: (0, import_valibot6.object)({
                 Message: json(schema)
               })
             })
           )
         }),
-        (input) => input.Records.map((record) => {
-          return record.Sns.Message;
-        })
+        (0, import_valibot6.transform)((v) => v.Records.map((r) => r.Sns.Message))
       )
     ],
-    "Invalid SNS Topic input"
+    message
   );
 };
 
 // src/schema/aws/dynamodb-stream.ts
-var import_valibot9 = require("valibot");
-var dynamoDbStream = (table) => {
-  const marshall = () => (0, import_valibot9.transform)((0, import_valibot9.unknown)(), (value) => table.unmarshall(value));
-  return (0, import_valibot9.transform)(
-    (0, import_valibot9.object)(
+var import_valibot7 = require("valibot");
+var dynamoDbStream = (table, message = "Invalid DynamoDB Stream payload") => {
+  const unmarshall = () => (0, import_valibot7.pipe)(
+    (0, import_valibot7.unknown)(),
+    (0, import_valibot7.transform)((v) => table.unmarshall(v))
+  );
+  return (0, import_valibot7.pipe)(
+    (0, import_valibot7.object)(
       {
-        Records: (0, import_valibot9.array)(
-          (0, import_valibot9.object)({
-            // For some reason picklist fails to build.
-            // eventName: picklist(['MODIFY', 'INSERT', 'REMOVE']),
-            eventName: (0, import_valibot9.union)([(0, import_valibot9.literal)("MODIFY"), (0, import_valibot9.literal)("INSERT"), (0, import_valibot9.literal)("REMOVE")]),
-            dynamodb: (0, import_valibot9.object)({
-              Keys: marshall(),
-              OldImage: (0, import_valibot9.optional)(marshall()),
-              NewImage: (0, import_valibot9.optional)(marshall())
+        Records: (0, import_valibot7.array)(
+          (0, import_valibot7.variant)("eventName", [
+            (0, import_valibot7.object)({
+              eventName: (0, import_valibot7.literal)("MODIFY"),
+              dynamodb: (0, import_valibot7.object)({
+                Keys: unmarshall(),
+                OldImage: unmarshall(),
+                NewImage: unmarshall()
+              })
+            }),
+            (0, import_valibot7.object)({
+              eventName: (0, import_valibot7.literal)("INSERT"),
+              dynamodb: (0, import_valibot7.object)({
+                Keys: unmarshall(),
+                NewImage: unmarshall()
+              })
+            }),
+            (0, import_valibot7.object)({
+              eventName: (0, import_valibot7.literal)("REMOVE"),
+              dynamodb: (0, import_valibot7.object)({
+                Keys: unmarshall(),
+                OldImage: unmarshall()
+              })
             })
-          })
+          ])
         )
       },
-      "Invalid DynamoDB Stream input"
+      message
     ),
-    (input) => {
+    (0, import_valibot7.transform)((input) => {
       return input.Records.map((record) => {
-        const item = record;
-        return {
+        const item = {
           event: record.eventName.toLowerCase(),
-          keys: item.dynamodb.Keys,
-          old: item.dynamodb.OldImage,
-          new: item.dynamodb.NewImage
+          keys: record.dynamodb.Keys
         };
+        if ("OldImage" in record.dynamodb) {
+          item.old = record.dynamodb.OldImage;
+        }
+        if ("NewImage" in record.dynamodb) {
+          item.new = record.dynamodb.NewImage;
+        }
+        return item;
       });
-    }
+    })
   );
 };
 
 // src/validation/positive.ts
 var import_big_float2 = require("@awsless/big-float");
-var import_valibot10 = require("valibot");
-function positive(error) {
-  return (0, import_valibot10.custom)((input) => (0, import_big_float2.gt)(input, import_big_float2.ZERO), error ?? "Invalid positive number");
+var import_valibot8 = require("valibot");
+function positive(message = "Invalid positive number") {
+  return (0, import_valibot8.check)((input) => (0, import_big_float2.isPositive)(input), message);
 }
 
 // src/validation/precision.ts
 var import_big_float3 = require("@awsless/big-float");
-var import_valibot11 = require("valibot");
-function precision(decimals, error) {
-  return (0, import_valibot11.custom)(
-    (input) => {
-      const big = (0, import_big_float3.parse)(input.toString());
-      return -big.exponent <= decimals;
-    },
-    error ?? `Invalid ${decimals} precision number`
-  );
+var import_valibot9 = require("valibot");
+function precision(decimals, message = `Invalid ${decimals} precision number`) {
+  return (0, import_valibot9.check)((input) => {
+    const big = (0, import_big_float3.parse)(input.toString());
+    return -big.exponent <= decimals;
+  }, message);
 }
 
 // src/validation/unique.ts
-var import_valibot12 = require("valibot");
-function unique(compare = (a, b) => a === b, error) {
-  return (0, import_valibot12.custom)((input) => {
+var import_valibot10 = require("valibot");
+function unique(compare = (a, b) => a === b, message = "None unique array") {
+  return (0, import_valibot10.check)((input) => {
     for (const x in input) {
       for (const y in input) {
         if (x !== y && compare(input[x], input[y])) {
@@ -254,22 +237,20 @@ function unique(compare = (a, b) => a === b, error) {
       }
     }
     return true;
-  }, error ?? "None unique array");
+  }, message);
 }
 
 // src/validation/duration.ts
-var import_valibot13 = require("valibot");
-function minDuration(min, error) {
-  return (0, import_valibot13.custom)((input) => input.value >= min.value, error ?? "Invalid duration");
+var import_valibot11 = require("valibot");
+function minDuration(min, message = "Invalid duration") {
+  return (0, import_valibot11.check)((input) => input.value >= min.value, message);
 }
-function maxDuration(max, error) {
-  return (0, import_valibot13.custom)((input) => input.value <= max.value, error ?? "Invalid duration");
+function maxDuration(max, message = "Invalid duration") {
+  return (0, import_valibot11.check)((input) => input.value <= max.value, message);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   bigfloat,
-  bigint,
-  date,
   duration,
   dynamoDbStream,
   json,

package/dist/index.d.cts

@@ -1,77 +1,95 @@
 import * as valibot from 'valibot';
-import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, UnknownSchema, Input } from 'valibot';
+import { BaseSchema, BaseIssue, ErrorMessage, InferOutput, InstanceIssue, InferInput, CheckIssue } from 'valibot';
 export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
-import { Duration, DurationFormat } from '@awsless/duration';
+import { Duration } from '@awsless/duration';
 import { AnyTable, PrimaryKey, Infer } from '@awsless/dynamodb';
 
-type JsonSchema<T extends BaseSchema> = SchemaWithTransform<StringSchema, Output<T>>;
-declare const json: <T extends BaseSchema>(schema: T) => JsonSchema<T>;
+type Schema$2 = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+type JsonIssue = BaseIssue<unknown>;
+type JsonSchema<T extends Schema$2> = BaseSchema<string, InferOutput<T>, JsonIssue>;
+declare const json: <T extends Schema$2>(schema: T, message?: ErrorMessage<JsonIssue>) => JsonSchema<T>;
 
-type BigFloatSchema = BaseSchema<string | number | BigFloat | {
-    exponent: number;
-    coefficient: bigint;
-}, BigFloat>;
-declare function bigfloat(pipe?: Pipe<BigFloat>): BigFloatSchema;
-declare function bigfloat(error?: ErrorMessage, pipe?: Pipe<BigFloat>): BigFloatSchema;
+type BigFloatIssue = BaseIssue<unknown>;
+type BigFloatSchema = BaseSchema<BigFloat | string | bigint | number, BigFloat, BigFloatIssue>;
+declare function bigfloat(message?: ErrorMessage<BigFloatIssue>): BigFloatSchema;
 
-type BigIntSchema = BaseSchema<string | bigint, bigint>;
-declare function bigint(pipe?: Pipe<bigint>): BigIntSchema;
-declare function bigint(error?: ErrorMessage, pipe?: Pipe<bigint>): BigIntSchema;
+type UuidIssue = BaseIssue<unknown>;
+type UuidSchema = BaseSchema<UUID, UUID, UuidIssue>;
+declare const uuid: (message?: ErrorMessage<UuidIssue>) => UuidSchema;
 
-type DateSchema = BaseSchema<string | Date, Date>;
-declare function date(pipe?: Pipe<Date>): DateSchema;
-declare function date(error?: ErrorMessage, pipe?: Pipe<Date>): DateSchema;
+type DurationIssue = InstanceIssue;
+type DurationSchema = BaseSchema<Duration, Duration, DurationIssue>;
+declare function duration(message?: ErrorMessage<DurationIssue>): DurationSchema;
 
-type UuidSchema = BaseSchema<UUID, UUID>;
-declare const uuid: (error?: ErrorMessage) => UuidSchema;
-
-type DurationSchema = BaseSchema<DurationFormat | Duration, Duration>;
-declare function duration(pipe?: Pipe<Duration>): DurationSchema;
-declare function duration(error?: ErrorMessage, pipe?: Pipe<Duration>): DurationSchema;
-
-type SqsQueueSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+type Schema$1 = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+type SqsQueueIssue = BaseIssue<unknown>;
+type SqsQueueSchema<S extends Schema$1> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
-        body: string | Input<S>;
+        body: string | InferInput<S>;
     }[];
-}, Output<S>[]>;
-declare const sqsQueue: <S extends BaseSchema = UnknownSchema>(body?: S) => SqsQueueSchema<S>;
+}, InferOutput<S>[], SqsQueueIssue>;
+declare const sqsQueue: <S extends Schema$1>(schema: S, message?: ErrorMessage<SqsQueueIssue>) => SqsQueueSchema<S>;
 
-type SnsTopicSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+type Schema = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+type SnsTopicIssue = BaseIssue<unknown>;
+type SnsTopicSchema<S extends Schema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
         Sns: {
-            Message: string | Input<S>;
+            Message: string | InferInput<S>;
         };
     }[];
-}, Output<S>[]>;
-declare const snsTopic: <S extends BaseSchema = UnknownSchema>(body?: S) => SnsTopicSchema<S>;
+}, InferOutput<S>[], SnsTopicIssue>;
+declare const snsTopic: <S extends Schema>(schema: S, message?: ErrorMessage<SnsTopicIssue>) => SnsTopicSchema<S>;
 
-type EventName = 'MODIFY' | 'INSERT' | 'REMOVE';
-type DynamoDBStreamSchema<T extends AnyTable> = BaseSchema<{
-    Records: {
-        eventName: EventName;
-        dynamodb: {
-            Keys: unknown;
-            OldImage?: unknown;
-            NewImage?: unknown;
-        };
-    }[];
-}, {
-    event: Lowercase<EventName>;
+type DynamoDBStreamInputRecord = {
+    eventName: 'MODIFY';
+    dynamodb: {
+        Keys: unknown;
+        OldImage: unknown;
+        NewImage: unknown;
+    };
+} | {
+    eventName: 'INSERT';
+    dynamodb: {
+        Keys: unknown;
+        NewImage: unknown;
+    };
+} | {
+    eventName: 'REMOVE';
+    dynamodb: {
+        Keys: unknown;
+        OldImage: unknown;
+    };
+};
+type DynamoDBStreamOutputRecord<T extends AnyTable> = {
+    event: 'modify';
+    keys: PrimaryKey<T>;
+    old: Infer<T>;
+    new: Infer<T>;
+} | {
+    event: 'insert';
     keys: PrimaryKey<T>;
-    old?: Infer<T>;
-    new?: Infer<T>;
-}[]>;
-declare const dynamoDbStream: <T extends AnyTable>(table: T) => DynamoDBStreamSchema<T>;
+    new: Infer<T>;
+} | {
+    event: 'remove';
+    keys: PrimaryKey<T>;
+    old: Infer<T>;
+};
+type DynamoDBStreamIssue = BaseIssue<unknown>;
+type DynamoDBStreamSchema<T extends AnyTable> = BaseSchema<{
+    Records: DynamoDBStreamInputRecord[];
+}, DynamoDBStreamOutputRecord<T>[], DynamoDBStreamIssue>;
+declare const dynamoDbStream: <T extends AnyTable>(table: T, message?: ErrorMessage<DynamoDBStreamIssue>) => DynamoDBStreamSchema<T>;
 
-declare function positive<T extends BigFloat | number>(error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function positive<T extends BigFloat | number>(message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
-declare function precision<T extends BigFloat | number>(decimals: number, error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function precision<T extends BigFloat | number>(decimals: number, message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
-declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
-declare function minDuration<T extends Duration>(min: Duration, error?: ErrorMessage): valibot.CustomValidation<T>;
-declare function maxDuration<T extends Duration>(max: Duration, error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function minDuration(min: Duration, message?: ErrorMessage<CheckIssue<Duration>>): valibot.CheckAction<Duration, ErrorMessage<CheckIssue<Duration>>>;
+declare function maxDuration(max: Duration, message?: ErrorMessage<CheckIssue<Duration>>): valibot.CheckAction<Duration, ErrorMessage<CheckIssue<Duration>>>;
 
-export { type BigFloatSchema, type BigIntSchema, type DateSchema, type DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, bigint, date, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, snsTopic, sqsQueue, unique, uuid };
+export { type BigFloatSchema, type DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, snsTopic, sqsQueue, unique, uuid };

package/dist/index.d.ts

@@ -1,77 +1,95 @@
 import * as valibot from 'valibot';
-import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, UnknownSchema, Input } from 'valibot';
+import { BaseSchema, BaseIssue, ErrorMessage, InferOutput, InstanceIssue, InferInput, CheckIssue } from 'valibot';
 export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
-import { Duration, DurationFormat } from '@awsless/duration';
+import { Duration } from '@awsless/duration';
 import { AnyTable, PrimaryKey, Infer } from '@awsless/dynamodb';
 
-type JsonSchema<T extends BaseSchema> = SchemaWithTransform<StringSchema, Output<T>>;
-declare const json: <T extends BaseSchema>(schema: T) => JsonSchema<T>;
+type Schema$2 = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+type JsonIssue = BaseIssue<unknown>;
+type JsonSchema<T extends Schema$2> = BaseSchema<string, InferOutput<T>, JsonIssue>;
+declare const json: <T extends Schema$2>(schema: T, message?: ErrorMessage<JsonIssue>) => JsonSchema<T>;
 
-type BigFloatSchema = BaseSchema<string | number | BigFloat | {
-    exponent: number;
-    coefficient: bigint;
-}, BigFloat>;
-declare function bigfloat(pipe?: Pipe<BigFloat>): BigFloatSchema;
-declare function bigfloat(error?: ErrorMessage, pipe?: Pipe<BigFloat>): BigFloatSchema;
+type BigFloatIssue = BaseIssue<unknown>;
+type BigFloatSchema = BaseSchema<BigFloat | string | bigint | number, BigFloat, BigFloatIssue>;
+declare function bigfloat(message?: ErrorMessage<BigFloatIssue>): BigFloatSchema;
 
-type BigIntSchema = BaseSchema<string | bigint, bigint>;
-declare function bigint(pipe?: Pipe<bigint>): BigIntSchema;
-declare function bigint(error?: ErrorMessage, pipe?: Pipe<bigint>): BigIntSchema;
+type UuidIssue = BaseIssue<unknown>;
+type UuidSchema = BaseSchema<UUID, UUID, UuidIssue>;
+declare const uuid: (message?: ErrorMessage<UuidIssue>) => UuidSchema;
 
-type DateSchema = BaseSchema<string | Date, Date>;
-declare function date(pipe?: Pipe<Date>): DateSchema;
-declare function date(error?: ErrorMessage, pipe?: Pipe<Date>): DateSchema;
+type DurationIssue = InstanceIssue;
+type DurationSchema = BaseSchema<Duration, Duration, DurationIssue>;
+declare function duration(message?: ErrorMessage<DurationIssue>): DurationSchema;
 
-type UuidSchema = BaseSchema<UUID, UUID>;
-declare const uuid: (error?: ErrorMessage) => UuidSchema;
-
-type DurationSchema = BaseSchema<DurationFormat | Duration, Duration>;
-declare function duration(pipe?: Pipe<Duration>): DurationSchema;
-declare function duration(error?: ErrorMessage, pipe?: Pipe<Duration>): DurationSchema;
-
-type SqsQueueSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+type Schema$1 = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+type SqsQueueIssue = BaseIssue<unknown>;
+type SqsQueueSchema<S extends Schema$1> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
-        body: string | Input<S>;
+        body: string | InferInput<S>;
     }[];
-}, Output<S>[]>;
-declare const sqsQueue: <S extends BaseSchema = UnknownSchema>(body?: S) => SqsQueueSchema<S>;
+}, InferOutput<S>[], SqsQueueIssue>;
+declare const sqsQueue: <S extends Schema$1>(schema: S, message?: ErrorMessage<SqsQueueIssue>) => SqsQueueSchema<S>;
 
-type SnsTopicSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+type Schema = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
+type SnsTopicIssue = BaseIssue<unknown>;
+type SnsTopicSchema<S extends Schema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
         Sns: {
-            Message: string | Input<S>;
+            Message: string | InferInput<S>;
         };
     }[];
-}, Output<S>[]>;
-declare const snsTopic: <S extends BaseSchema = UnknownSchema>(body?: S) => SnsTopicSchema<S>;
+}, InferOutput<S>[], SnsTopicIssue>;
+declare const snsTopic: <S extends Schema>(schema: S, message?: ErrorMessage<SnsTopicIssue>) => SnsTopicSchema<S>;
 
-type EventName = 'MODIFY' | 'INSERT' | 'REMOVE';
-type DynamoDBStreamSchema<T extends AnyTable> = BaseSchema<{
-    Records: {
-        eventName: EventName;
-        dynamodb: {
-            Keys: unknown;
-            OldImage?: unknown;
-            NewImage?: unknown;
-        };
-    }[];
-}, {
-    event: Lowercase<EventName>;
+type DynamoDBStreamInputRecord = {
+    eventName: 'MODIFY';
+    dynamodb: {
+        Keys: unknown;
+        OldImage: unknown;
+        NewImage: unknown;
+    };
+} | {
+    eventName: 'INSERT';
+    dynamodb: {
+        Keys: unknown;
+        NewImage: unknown;
+    };
+} | {
+    eventName: 'REMOVE';
+    dynamodb: {
+        Keys: unknown;
+        OldImage: unknown;
+    };
+};
+type DynamoDBStreamOutputRecord<T extends AnyTable> = {
+    event: 'modify';
+    keys: PrimaryKey<T>;
+    old: Infer<T>;
+    new: Infer<T>;
+} | {
+    event: 'insert';
     keys: PrimaryKey<T>;
-    old?: Infer<T>;
-    new?: Infer<T>;
-}[]>;
-declare const dynamoDbStream: <T extends AnyTable>(table: T) => DynamoDBStreamSchema<T>;
+    new: Infer<T>;
+} | {
+    event: 'remove';
+    keys: PrimaryKey<T>;
+    old: Infer<T>;
+};
+type DynamoDBStreamIssue = BaseIssue<unknown>;
+type DynamoDBStreamSchema<T extends AnyTable> = BaseSchema<{
+    Records: DynamoDBStreamInputRecord[];
+}, DynamoDBStreamOutputRecord<T>[], DynamoDBStreamIssue>;
+declare const dynamoDbStream: <T extends AnyTable>(table: T, message?: ErrorMessage<DynamoDBStreamIssue>) => DynamoDBStreamSchema<T>;
 
-declare function positive<T extends BigFloat | number>(error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function positive<T extends BigFloat | number>(message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
-declare function precision<T extends BigFloat | number>(decimals: number, error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function precision<T extends BigFloat | number>(decimals: number, message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
-declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
-declare function minDuration<T extends Duration>(min: Duration, error?: ErrorMessage): valibot.CustomValidation<T>;
-declare function maxDuration<T extends Duration>(max: Duration, error?: ErrorMessage): valibot.CustomValidation<T>;
+declare function minDuration(min: Duration, message?: ErrorMessage<CheckIssue<Duration>>): valibot.CheckAction<Duration, ErrorMessage<CheckIssue<Duration>>>;
+declare function maxDuration(max: Duration, message?: ErrorMessage<CheckIssue<Duration>>): valibot.CheckAction<Duration, ErrorMessage<CheckIssue<Duration>>>;
 
-export { type BigFloatSchema, type BigIntSchema, type DateSchema, type DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, bigint, date, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, snsTopic, sqsQueue, unique, uuid };
+export { type BigFloatSchema, type DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, snsTopic, sqsQueue, unique, uuid };

package/dist/index.js

@@ -3,221 +3,217 @@ export * from "valibot";
 
 // src/schema/json.ts
 import { parse } from "@awsless/json";
-import { string, transform } from "valibot";
-var json = (schema) => {
-  return transform(
-    string(),
-    (value) => {
+import { pipe, rawTransform, string } from "valibot";
+var json = (schema, message = "Invalid JSON") => {
+  return pipe(
+    string(message),
+    rawTransform((ctx) => {
+      let result;
       try {
-        return parse(value);
-      } catch (error) {
-        return null;
+        result = parse(ctx.dataset.value);
+      } catch (_error) {
+        ctx.addIssue({
+          message
+        });
+        return ctx.NEVER;
       }
-    },
+      return result;
+    }),
     schema
   );
 };
 
 // src/schema/bigfloat.ts
-import { BigFloat } from "@awsless/big-float";
+import { BigFloat, parse as parse2 } from "@awsless/big-float";
 import {
   bigint,
-  custom,
-  defaultArgs,
+  decimal,
   instance,
   number,
-  object,
+  pipe as pipe2,
   string as string2,
-  transform as transform2,
+  transform,
   union
 } from "valibot";
-var make = (value) => new BigFloat(value);
-function bigfloat(arg1, arg2) {
-  const [msg, pipe] = defaultArgs(arg1, arg2);
-  const error = msg ?? "Invalid bigfloat";
+function bigfloat(message = "Invalid bigfloat") {
   return union(
     [
-      instance(BigFloat, pipe),
-      transform2(string2([custom((input) => input !== "" && !isNaN(Number(input)), error)]), make, pipe),
-      transform2(number(), make, pipe),
-      transform2(
-        object({
-          exponent: number(),
-          coefficient: bigint()
-        }),
-        make,
-        pipe
-      )
-    ],
-    error
-  );
-}
-
-// src/schema/bigint.ts
-import { bigint as base, defaultArgs as defaultArgs2, regex, string as string3, transform as transform3, union as union2 } from "valibot";
-function bigint2(arg1, arg2) {
-  const [error, pipe] = defaultArgs2(arg1, arg2);
-  return union2(
-    [
-      base(pipe),
-      transform3(
-        string3([regex(/^-?[0-9]+$/)]),
-        (input) => {
-          return BigInt(input);
-        },
-        base(pipe)
+      instance(BigFloat),
+      pipe2(
+        string2(),
+        decimal(),
+        transform((v) => parse2(v))
+      ),
+      pipe2(
+        bigint(),
+        transform((v) => parse2(v))
+      ),
+      pipe2(
+        number(),
+        transform((v) => parse2(v))
       )
     ],
-    error ?? "Invalid BigInt"
-  );
-}
-
-// src/schema/date.ts
-import { date as base2, defaultArgs as defaultArgs3, string as string4, transform as transform4, union as union3 } from "valibot";
-function date(arg1, arg2) {
-  const [error, pipe] = defaultArgs3(arg1, arg2);
-  return union3(
-    [
-      base2(pipe),
-      transform4(
-        string4(),
-        (input) => {
-          return new Date(input);
-        },
-        base2(pipe)
-      )
-    ],
-    error ?? "Invalid date"
+    message
   );
 }
 
 // src/schema/uuid.ts
-import { uuid as base3, string as string5 } from "valibot";
-var uuid = (error) => {
-  return string5(error ?? "Invalid UUID", [base3()]);
+import { uuid as base, pipe as pipe3, string as string3 } from "valibot";
+var uuid = (message = "Invalid UUID") => {
+  return pipe3(string3(message), base(message));
 };
 
 // src/schema/duration.ts
 import { Duration } from "@awsless/duration";
-import { defaultArgs as defaultArgs4, instance as instance2 } from "valibot";
-function duration(arg1, arg2) {
-  const [msg, pipe] = defaultArgs4(arg1, arg2);
-  const error = msg ?? "Invalid duration";
-  return instance2(Duration, error, pipe);
+import { instance as instance2 } from "valibot";
+function duration(message = "Invalid duration") {
+  return instance2(Duration, message);
 }
 
 // src/schema/aws/sqs-queue.ts
-import { array, object as object2, transform as transform5, union as union4, unknown } from "valibot";
-var sqsQueue = (body) => {
-  const schema = body ?? unknown();
-  return union4(
+import {
+  array,
+  object,
+  pipe as pipe4,
+  transform as transform2,
+  union as union2
+} from "valibot";
+var sqsQueue = (schema, message = "Invalid SQS Queue payload") => {
+  return union2(
     [
-      transform5(schema, (input) => [input]),
-      array(schema),
-      transform5(
-        object2({
+      // Prioritize the expected payload during production
+      pipe4(
+        object({
           Records: array(
-            object2({
+            object({
               body: json(schema)
             })
           )
         }),
-        (input) => input.Records.map((record) => {
-          return record.body;
-        })
-      )
+        transform2((v) => v.Records.map((r) => r.body))
+      ),
+      // These are allowed during testing
+      pipe4(
+        schema,
+        transform2((v) => [v])
+      ),
+      array(schema)
     ],
-    "Invalid SQS Queue input"
+    message
   );
 };
 
 // src/schema/aws/sns-topic.ts
-import { array as array2, object as object3, transform as transform6, union as union5, unknown as unknown2 } from "valibot";
-var snsTopic = (body) => {
-  const schema = body ?? unknown2();
-  return union5(
+import {
+  array as array2,
+  object as object2,
+  pipe as pipe5,
+  transform as transform3,
+  union as union3
+} from "valibot";
+var snsTopic = (schema, message = "Invalid SNS Topic payload") => {
+  return union3(
     [
-      transform6(schema, (input) => [input]),
+      pipe5(
+        schema,
+        transform3((v) => [v])
+      ),
       array2(schema),
-      transform6(
-        object3({
+      pipe5(
+        object2({
           Records: array2(
-            object3({
-              Sns: object3({
+            object2({
+              Sns: object2({
                 Message: json(schema)
               })
             })
           )
         }),
-        (input) => input.Records.map((record) => {
-          return record.Sns.Message;
-        })
+        transform3((v) => v.Records.map((r) => r.Sns.Message))
       )
     ],
-    "Invalid SNS Topic input"
+    message
   );
 };
 
 // src/schema/aws/dynamodb-stream.ts
-import { array as array3, literal, object as object4, optional, transform as transform7, union as union6, unknown as unknown3 } from "valibot";
-var dynamoDbStream = (table) => {
-  const marshall = () => transform7(unknown3(), (value) => table.unmarshall(value));
-  return transform7(
-    object4(
+import { array as array3, literal, object as object3, pipe as pipe6, transform as transform4, unknown, variant } from "valibot";
+var dynamoDbStream = (table, message = "Invalid DynamoDB Stream payload") => {
+  const unmarshall = () => pipe6(
+    unknown(),
+    transform4((v) => table.unmarshall(v))
+  );
+  return pipe6(
+    object3(
       {
         Records: array3(
-          object4({
-            // For some reason picklist fails to build.
-            // eventName: picklist(['MODIFY', 'INSERT', 'REMOVE']),
-            eventName: union6([literal("MODIFY"), literal("INSERT"), literal("REMOVE")]),
-            dynamodb: object4({
-              Keys: marshall(),
-              OldImage: optional(marshall()),
-              NewImage: optional(marshall())
+          variant("eventName", [
+            object3({
+              eventName: literal("MODIFY"),
+              dynamodb: object3({
+                Keys: unmarshall(),
+                OldImage: unmarshall(),
+                NewImage: unmarshall()
+              })
+            }),
+            object3({
+              eventName: literal("INSERT"),
+              dynamodb: object3({
+                Keys: unmarshall(),
+                NewImage: unmarshall()
+              })
+            }),
+            object3({
+              eventName: literal("REMOVE"),
+              dynamodb: object3({
+                Keys: unmarshall(),
+                OldImage: unmarshall()
+              })
             })
-          })
+          ])
         )
       },
-      "Invalid DynamoDB Stream input"
+      message
     ),
-    (input) => {
+    transform4((input) => {
       return input.Records.map((record) => {
-        const item = record;
-        return {
+        const item = {
           event: record.eventName.toLowerCase(),
-          keys: item.dynamodb.Keys,
-          old: item.dynamodb.OldImage,
-          new: item.dynamodb.NewImage
+          keys: record.dynamodb.Keys
         };
+        if ("OldImage" in record.dynamodb) {
+          item.old = record.dynamodb.OldImage;
+        }
+        if ("NewImage" in record.dynamodb) {
+          item.new = record.dynamodb.NewImage;
+        }
+        return item;
       });
-    }
+    })
   );
 };
 
 // src/validation/positive.ts
-import { ZERO, gt } from "@awsless/big-float";
-import { custom as custom2 } from "valibot";
-function positive(error) {
-  return custom2((input) => gt(input, ZERO), error ?? "Invalid positive number");
+import { isPositive } from "@awsless/big-float";
+import { check } from "valibot";
+function positive(message = "Invalid positive number") {
+  return check((input) => isPositive(input), message);
 }
 
 // src/validation/precision.ts
-import { parse as parse2 } from "@awsless/big-float";
-import { custom as custom3 } from "valibot";
-function precision(decimals, error) {
-  return custom3(
-    (input) => {
-      const big = parse2(input.toString());
-      return -big.exponent <= decimals;
-    },
-    error ?? `Invalid ${decimals} precision number`
-  );
+import { parse as parse3 } from "@awsless/big-float";
+import { check as check2 } from "valibot";
+function precision(decimals, message = `Invalid ${decimals} precision number`) {
+  return check2((input) => {
+    const big = parse3(input.toString());
+    return -big.exponent <= decimals;
+  }, message);
 }
 
 // src/validation/unique.ts
-import { custom as custom4 } from "valibot";
-function unique(compare = (a, b) => a === b, error) {
-  return custom4((input) => {
+import { check as check3 } from "valibot";
+function unique(compare = (a, b) => a === b, message = "None unique array") {
+  return check3((input) => {
     for (const x in input) {
       for (const y in input) {
         if (x !== y && compare(input[x], input[y])) {
@@ -226,21 +222,19 @@ function unique(compare = (a, b) => a === b, error) {
       }
     }
     return true;
-  }, error ?? "None unique array");
+  }, message);
 }
 
 // src/validation/duration.ts
-import { custom as custom5 } from "valibot";
-function minDuration(min, error) {
-  return custom5((input) => input.value >= min.value, error ?? "Invalid duration");
+import { check as check4 } from "valibot";
+function minDuration(min, message = "Invalid duration") {
+  return check4((input) => input.value >= min.value, message);
 }
-function maxDuration(max, error) {
-  return custom5((input) => input.value <= max.value, error ?? "Invalid duration");
+function maxDuration(max, message = "Invalid duration") {
+  return check4((input) => input.value <= max.value, message);
 }
 export {
   bigfloat,
-  bigint2 as bigint,
-  date,
   duration,
   dynamoDbStream,
   json,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awsless/validate",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -25,18 +25,18 @@
   },
   "peerDependencies": {
     "@awsless/big-float": "^0.1.5",
-    "@awsless/dynamodb": "^0.2.12",
-    "@awsless/duration": "^0.0.3",
+    "@awsless/duration": "^0.0.4",
+    "@awsless/dynamodb": "^0.3.2",
     "@awsless/json": "^0.0.10"
   },
   "devDependencies": {
     "@awsless/big-float": "^0.1.5",
-    "@awsless/duration": "^0.0.3",
-    "@awsless/dynamodb": "^0.2.12",
+    "@awsless/duration": "^0.0.4",
+    "@awsless/dynamodb": "^0.3.2",
     "@awsless/json": "^0.0.10"
   },
   "dependencies": {
-    "valibot": "^0.30.0"
+    "valibot": "^1.2.0"
   },
   "scripts": {
     "test": "pnpm code test",