@awsless/validate 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -29,6 +29,7 @@ __export(index_exports, {
   minDuration: () => minDuration,
   positive: () => positive,
   precision: () => precision,
+  s3Event: () => s3Event,
   snsTopic: () => snsTopic,
   sqsQueue: () => sqsQueue,
   unique: () => unique,
@@ -129,11 +130,7 @@ var import_valibot6 = require("valibot");
 var snsTopic = (schema, message = "Invalid SNS Topic payload") => {
   return (0, import_valibot6.union)(
     [
-      (0, import_valibot6.pipe)(
-        schema,
-        (0, import_valibot6.transform)((v) => [v])
-      ),
-      (0, import_valibot6.array)(schema),
+      // Prioritize the expected payload during production
       (0, import_valibot6.pipe)(
         (0, import_valibot6.object)({
           Records: (0, import_valibot6.array)(
@@ -145,7 +142,13 @@ var snsTopic = (schema, message = "Invalid SNS Topic payload") => {
           )
         }),
         (0, import_valibot6.transform)((v) => v.Records.map((r) => r.Sns.Message))
-      )
+      ),
+      // These are allowed during testing
+      (0, import_valibot6.pipe)(
+        schema,
+        (0, import_valibot6.transform)((v) => [v])
+      ),
+      (0, import_valibot6.array)(schema)
     ],
     message
   );
@@ -208,27 +211,82 @@ var dynamoDbStream = (table, message = "Invalid DynamoDB Stream payload") => {
   );
 };
 
+// src/schema/aws/s3-event.ts
+var import_valibot8 = require("valibot");
+var s3Event = () => {
+  const schema = (0, import_valibot8.object)({
+    event: (0, import_valibot8.string)(),
+    bucket: (0, import_valibot8.string)(),
+    key: (0, import_valibot8.string)(),
+    size: (0, import_valibot8.number)(),
+    eTag: (0, import_valibot8.string)(),
+    time: (0, import_valibot8.date)()
+  });
+  return (0, import_valibot8.union)(
+    [
+      // Prioritize the expected payload during production
+      (0, import_valibot8.pipe)(
+        (0, import_valibot8.object)({
+          Records: (0, import_valibot8.array)(
+            (0, import_valibot8.object)({
+              eventTime: (0, import_valibot8.pipe)((0, import_valibot8.string)(), (0, import_valibot8.toDate)()),
+              eventName: (0, import_valibot8.string)(),
+              s3: (0, import_valibot8.object)({
+                bucket: (0, import_valibot8.object)({
+                  name: (0, import_valibot8.string)()
+                }),
+                object: (0, import_valibot8.object)({
+                  key: (0, import_valibot8.string)(),
+                  size: (0, import_valibot8.number)(),
+                  eTag: (0, import_valibot8.string)()
+                })
+              })
+            })
+          )
+        }),
+        (0, import_valibot8.transform)((input) => {
+          return input.Records.map((record) => ({
+            event: record.eventName,
+            time: record.eventTime,
+            bucket: record.s3.bucket.name,
+            key: record.s3.object.key,
+            size: record.s3.object.size,
+            eTag: record.s3.object.eTag
+          }));
+        })
+      ),
+      // These are allowed during testing
+      (0, import_valibot8.pipe)(
+        schema,
+        (0, import_valibot8.transform)((v) => [v])
+      ),
+      (0, import_valibot8.array)(schema)
+    ],
+    "Invalid S3 Event payload"
+  );
+};
+
 // src/validation/positive.ts
 var import_big_float2 = require("@awsless/big-float");
-var import_valibot8 = require("valibot");
+var import_valibot9 = require("valibot");
 function positive(message = "Invalid positive number") {
-  return (0, import_valibot8.check)((input) => (0, import_big_float2.isPositive)(input), message);
+  return (0, import_valibot9.check)((input) => (0, import_big_float2.isPositive)(input), message);
 }
 
 // src/validation/precision.ts
 var import_big_float3 = require("@awsless/big-float");
-var import_valibot9 = require("valibot");
+var import_valibot10 = require("valibot");
 function precision(decimals, message = `Invalid ${decimals} precision number`) {
-  return (0, import_valibot9.check)((input) => {
+  return (0, import_valibot10.check)((input) => {
     const big = (0, import_big_float3.parse)(input.toString());
     return -big.exponent <= decimals;
   }, message);
 }
 
 // src/validation/unique.ts
-var import_valibot10 = require("valibot");
+var import_valibot11 = require("valibot");
 function unique(compare = (a, b) => a === b, message = "None unique array") {
-  return (0, import_valibot10.check)((input) => {
+  return (0, import_valibot11.check)((input) => {
     for (const x in input) {
       for (const y in input) {
         if (x !== y && compare(input[x], input[y])) {
@@ -241,12 +299,12 @@ function unique(compare = (a, b) => a === b, message = "None unique array") {
 }
 
 // src/validation/duration.ts
-var import_valibot11 = require("valibot");
+var import_valibot12 = require("valibot");
 function minDuration(min, message = "Invalid duration") {
-  return (0, import_valibot11.check)((input) => input.value >= min.value, message);
+  return (0, import_valibot12.check)((input) => input.value >= min.value, message);
 }
 function maxDuration(max, message = "Invalid duration") {
-  return (0, import_valibot11.check)((input) => input.value <= max.value, message);
+  return (0, import_valibot12.check)((input) => input.value <= max.value, message);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -258,6 +316,7 @@ function maxDuration(max, message = "Invalid duration") {
   minDuration,
   positive,
   precision,
+  s3Event,
   snsTopic,
   sqsQueue,
   unique,

package/dist/index.d.cts

@@ -1,47 +1,38 @@
 import * as valibot from 'valibot';
-import { BaseSchema, BaseIssue, ErrorMessage, InferOutput, InstanceIssue, InferInput, CheckIssue } from 'valibot';
+import { GenericSchema, ErrorMessage, GenericIssue, BaseSchema, InferOutput, InferInput, CheckIssue } from 'valibot';
 export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
 import { Duration } from '@awsless/duration';
 import { AnyTable, PrimaryKey, Infer } from '@awsless/dynamodb';
 
-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 JsonSchema<T extends GenericSchema> = BaseSchema<string, InferOutput<T>, GenericIssue>;
+declare const json: <T extends GenericSchema>(schema: T, message?: ErrorMessage<GenericIssue>) => JsonSchema<T>;
 
-type BigFloatIssue = BaseIssue<unknown>;
-type BigFloatSchema = BaseSchema<BigFloat | string | bigint | number, BigFloat, BigFloatIssue>;
-declare function bigfloat(message?: ErrorMessage<BigFloatIssue>): BigFloatSchema;
+type BigFloatSchema = BaseSchema<BigFloat | string | bigint | number, BigFloat, GenericIssue>;
+declare function bigfloat(message?: ErrorMessage<GenericIssue>): BigFloatSchema;
 
-type UuidIssue = BaseIssue<unknown>;
-type UuidSchema = BaseSchema<UUID, UUID, UuidIssue>;
-declare const uuid: (message?: ErrorMessage<UuidIssue>) => UuidSchema;
+type UuidSchema = BaseSchema<UUID, UUID, GenericIssue>;
+declare const uuid: (message?: ErrorMessage<GenericIssue>) => UuidSchema;
 
-type DurationIssue = InstanceIssue;
-type DurationSchema = BaseSchema<Duration, Duration, DurationIssue>;
-declare function duration(message?: ErrorMessage<DurationIssue>): DurationSchema;
+type DurationSchema = BaseSchema<Duration, Duration, GenericIssue>;
+declare function duration(message?: ErrorMessage<GenericIssue>): DurationSchema;
 
-type Schema$1 = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
-type SqsQueueIssue = BaseIssue<unknown>;
-type SqsQueueSchema<S extends Schema$1> = BaseSchema<InferInput<S> | InferInput<S>[] | {
+type SqsQueueSchema<S extends GenericSchema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
         body: string | InferInput<S>;
     }[];
-}, InferOutput<S>[], SqsQueueIssue>;
-declare const sqsQueue: <S extends Schema$1>(schema: S, message?: ErrorMessage<SqsQueueIssue>) => SqsQueueSchema<S>;
+}, InferOutput<S>[], GenericIssue>;
+declare const sqsQueue: <S extends GenericSchema>(schema: S, message?: ErrorMessage<GenericIssue>) => SqsQueueSchema<S>;
 
-type Schema = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
-type SnsTopicIssue = BaseIssue<unknown>;
-type SnsTopicSchema<S extends Schema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
+type SnsTopicSchema<S extends GenericSchema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
         Sns: {
             Message: string | InferInput<S>;
         };
     }[];
-}, InferOutput<S>[], SnsTopicIssue>;
-declare const snsTopic: <S extends Schema>(schema: S, message?: ErrorMessage<SnsTopicIssue>) => SnsTopicSchema<S>;
+}, InferOutput<S>[], GenericIssue>;
+declare const snsTopic: <S extends GenericSchema>(schema: S, message?: ErrorMessage<GenericIssue>) => SnsTopicSchema<S>;
 
 type DynamoDBStreamInputRecord = {
     eventName: 'MODIFY';
@@ -77,11 +68,25 @@ type DynamoDBStreamOutputRecord<T extends AnyTable> = {
     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>;
+}, DynamoDBStreamOutputRecord<T>[], GenericIssue>;
+declare const dynamoDbStream: <T extends AnyTable>(table: T, message?: ErrorMessage<GenericIssue>) => DynamoDBStreamSchema<T>;
+
+type S3EventOutput = {
+    event: string;
+    time: Date;
+    bucket: string;
+    key: string;
+    size: number;
+    eTag: string;
+};
+type S3EventSchema = BaseSchema<S3EventOutput | S3EventOutput[] | {
+    Records: {
+        eventTime: string;
+    }[];
+}, S3EventOutput[], GenericIssue>;
+declare const s3Event: () => S3EventSchema;
 
 declare function positive<T extends BigFloat | number>(message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
@@ -92,4 +97,4 @@ declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number])
 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 DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, snsTopic, sqsQueue, unique, uuid };
+export { type BigFloatSchema, type DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type S3EventSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, s3Event, snsTopic, sqsQueue, unique, uuid };

package/dist/index.d.ts

@@ -1,47 +1,38 @@
 import * as valibot from 'valibot';
-import { BaseSchema, BaseIssue, ErrorMessage, InferOutput, InstanceIssue, InferInput, CheckIssue } from 'valibot';
+import { GenericSchema, ErrorMessage, GenericIssue, BaseSchema, InferOutput, InferInput, CheckIssue } from 'valibot';
 export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
 import { Duration } from '@awsless/duration';
 import { AnyTable, PrimaryKey, Infer } from '@awsless/dynamodb';
 
-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 JsonSchema<T extends GenericSchema> = BaseSchema<string, InferOutput<T>, GenericIssue>;
+declare const json: <T extends GenericSchema>(schema: T, message?: ErrorMessage<GenericIssue>) => JsonSchema<T>;
 
-type BigFloatIssue = BaseIssue<unknown>;
-type BigFloatSchema = BaseSchema<BigFloat | string | bigint | number, BigFloat, BigFloatIssue>;
-declare function bigfloat(message?: ErrorMessage<BigFloatIssue>): BigFloatSchema;
+type BigFloatSchema = BaseSchema<BigFloat | string | bigint | number, BigFloat, GenericIssue>;
+declare function bigfloat(message?: ErrorMessage<GenericIssue>): BigFloatSchema;
 
-type UuidIssue = BaseIssue<unknown>;
-type UuidSchema = BaseSchema<UUID, UUID, UuidIssue>;
-declare const uuid: (message?: ErrorMessage<UuidIssue>) => UuidSchema;
+type UuidSchema = BaseSchema<UUID, UUID, GenericIssue>;
+declare const uuid: (message?: ErrorMessage<GenericIssue>) => UuidSchema;
 
-type DurationIssue = InstanceIssue;
-type DurationSchema = BaseSchema<Duration, Duration, DurationIssue>;
-declare function duration(message?: ErrorMessage<DurationIssue>): DurationSchema;
+type DurationSchema = BaseSchema<Duration, Duration, GenericIssue>;
+declare function duration(message?: ErrorMessage<GenericIssue>): DurationSchema;
 
-type Schema$1 = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
-type SqsQueueIssue = BaseIssue<unknown>;
-type SqsQueueSchema<S extends Schema$1> = BaseSchema<InferInput<S> | InferInput<S>[] | {
+type SqsQueueSchema<S extends GenericSchema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
         body: string | InferInput<S>;
     }[];
-}, InferOutput<S>[], SqsQueueIssue>;
-declare const sqsQueue: <S extends Schema$1>(schema: S, message?: ErrorMessage<SqsQueueIssue>) => SqsQueueSchema<S>;
+}, InferOutput<S>[], GenericIssue>;
+declare const sqsQueue: <S extends GenericSchema>(schema: S, message?: ErrorMessage<GenericIssue>) => SqsQueueSchema<S>;
 
-type Schema = BaseSchema<unknown, unknown, BaseIssue<unknown>>;
-type SnsTopicIssue = BaseIssue<unknown>;
-type SnsTopicSchema<S extends Schema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
+type SnsTopicSchema<S extends GenericSchema> = BaseSchema<InferInput<S> | InferInput<S>[] | {
     Records: {
         Sns: {
             Message: string | InferInput<S>;
         };
     }[];
-}, InferOutput<S>[], SnsTopicIssue>;
-declare const snsTopic: <S extends Schema>(schema: S, message?: ErrorMessage<SnsTopicIssue>) => SnsTopicSchema<S>;
+}, InferOutput<S>[], GenericIssue>;
+declare const snsTopic: <S extends GenericSchema>(schema: S, message?: ErrorMessage<GenericIssue>) => SnsTopicSchema<S>;
 
 type DynamoDBStreamInputRecord = {
     eventName: 'MODIFY';
@@ -77,11 +68,25 @@ type DynamoDBStreamOutputRecord<T extends AnyTable> = {
     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>;
+}, DynamoDBStreamOutputRecord<T>[], GenericIssue>;
+declare const dynamoDbStream: <T extends AnyTable>(table: T, message?: ErrorMessage<GenericIssue>) => DynamoDBStreamSchema<T>;
+
+type S3EventOutput = {
+    event: string;
+    time: Date;
+    bucket: string;
+    key: string;
+    size: number;
+    eTag: string;
+};
+type S3EventSchema = BaseSchema<S3EventOutput | S3EventOutput[] | {
+    Records: {
+        eventTime: string;
+    }[];
+}, S3EventOutput[], GenericIssue>;
+declare const s3Event: () => S3EventSchema;
 
 declare function positive<T extends BigFloat | number>(message?: ErrorMessage<CheckIssue<T>>): valibot.CheckAction<T, ErrorMessage<CheckIssue<T>>>;
 
@@ -92,4 +97,4 @@ declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number])
 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 DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, snsTopic, sqsQueue, unique, uuid };
+export { type BigFloatSchema, type DurationSchema, type DynamoDBStreamSchema, type JsonSchema, type S3EventSchema, type SnsTopicSchema, type SqsQueueSchema, type UuidSchema, bigfloat, duration, dynamoDbStream, json, maxDuration, minDuration, positive, precision, s3Event, snsTopic, sqsQueue, unique, uuid };

package/dist/index.js

@@ -114,11 +114,7 @@ import {
 var snsTopic = (schema, message = "Invalid SNS Topic payload") => {
   return union3(
     [
-      pipe5(
-        schema,
-        transform3((v) => [v])
-      ),
-      array2(schema),
+      // Prioritize the expected payload during production
       pipe5(
         object2({
           Records: array2(
@@ -130,14 +126,28 @@ var snsTopic = (schema, message = "Invalid SNS Topic payload") => {
           )
         }),
         transform3((v) => v.Records.map((r) => r.Sns.Message))
-      )
+      ),
+      // These are allowed during testing
+      pipe5(
+        schema,
+        transform3((v) => [v])
+      ),
+      array2(schema)
     ],
     message
   );
 };
 
 // src/schema/aws/dynamodb-stream.ts
-import { array as array3, literal, object as object3, pipe as pipe6, transform as transform4, unknown, variant } from "valibot";
+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(),
@@ -193,6 +203,61 @@ var dynamoDbStream = (table, message = "Invalid DynamoDB Stream payload") => {
   );
 };
 
+// src/schema/aws/s3-event.ts
+import { array as array4, date, number as number2, object as object4, pipe as pipe7, string as string4, toDate, transform as transform5, union as union4 } from "valibot";
+var s3Event = () => {
+  const schema = object4({
+    event: string4(),
+    bucket: string4(),
+    key: string4(),
+    size: number2(),
+    eTag: string4(),
+    time: date()
+  });
+  return union4(
+    [
+      // Prioritize the expected payload during production
+      pipe7(
+        object4({
+          Records: array4(
+            object4({
+              eventTime: pipe7(string4(), toDate()),
+              eventName: string4(),
+              s3: object4({
+                bucket: object4({
+                  name: string4()
+                }),
+                object: object4({
+                  key: string4(),
+                  size: number2(),
+                  eTag: string4()
+                })
+              })
+            })
+          )
+        }),
+        transform5((input) => {
+          return input.Records.map((record) => ({
+            event: record.eventName,
+            time: record.eventTime,
+            bucket: record.s3.bucket.name,
+            key: record.s3.object.key,
+            size: record.s3.object.size,
+            eTag: record.s3.object.eTag
+          }));
+        })
+      ),
+      // These are allowed during testing
+      pipe7(
+        schema,
+        transform5((v) => [v])
+      ),
+      array4(schema)
+    ],
+    "Invalid S3 Event payload"
+  );
+};
+
 // src/validation/positive.ts
 import { isPositive } from "@awsless/big-float";
 import { check } from "valibot";
@@ -242,6 +307,7 @@ export {
   minDuration,
   positive,
   precision,
+  s3Event,
   snsTopic,
   sqsQueue,
   unique,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awsless/validate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -24,15 +24,15 @@
     }
   },
   "peerDependencies": {
+    "@awsless/big-float": "^0.1.5",
     "@awsless/duration": "^0.0.4",
     "@awsless/json": "^0.0.10",
-    "@awsless/dynamodb": "^0.3.2",
-    "@awsless/big-float": "^0.1.5"
+    "@awsless/dynamodb": "^0.3.2"
   },
   "devDependencies": {
-    "@awsless/big-float": "^0.1.5",
-    "@awsless/dynamodb": "^0.3.2",
     "@awsless/duration": "^0.0.4",
+    "@awsless/dynamodb": "^0.3.2",
+    "@awsless/big-float": "^0.1.5",
     "@awsless/json": "^0.0.10"
   },
   "dependencies": {