@awsless/validate 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -23,9 +23,12 @@ var src_exports = {};
 __export(src_exports, {
   bigfloat: () => bigfloat,
   date: () => date,
+  dynamoDbStream: () => dynamoDbStream,
   json: () => json,
   positive: () => positive,
   precision: () => precision,
+  snsTopic: () => snsTopic,
+  sqsQueue: () => sqsQueue,
   unique: () => unique,
   uuid: () => uuid
 });
@@ -109,46 +112,135 @@ var uuid = () => {
   return (0, import_valibot4.transform)((0, import_valibot4.string)([(0, import_valibot4.uuid)()]), (v) => v);
 };
 
+// src/schema/aws/sqs-queue.ts
+var import_valibot5 = require("valibot");
+var sqsQueue = (body) => {
+  const schema = body ?? (0, import_valibot5.unknown)();
+  return (0, import_valibot5.union)(
+    [
+      (0, import_valibot5.transform)(schema, (input) => [input]),
+      (0, import_valibot5.array)(schema),
+      (0, import_valibot5.transform)(
+        (0, import_valibot5.object)({
+          Records: (0, import_valibot5.array)(
+            (0, import_valibot5.object)({
+              body: json(schema)
+            })
+          )
+        }),
+        (input) => input.Records.map((record) => {
+          return record.body;
+        })
+      )
+    ],
+    "Invalid SQS Queue input"
+  );
+};
+
+// src/schema/aws/sns-topic.ts
+var import_valibot6 = require("valibot");
+var snsTopic = (body) => {
+  const schema = body ?? (0, import_valibot6.unknown)();
+  return (0, import_valibot6.union)(
+    [
+      (0, import_valibot6.transform)(schema, (input) => [input]),
+      (0, import_valibot6.array)(schema),
+      (0, import_valibot6.transform)(
+        (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;
+        })
+      )
+    ],
+    "Invalid SNS Topic input"
+  );
+};
+
+// src/schema/aws/dynamodb-stream.ts
+var import_valibot7 = require("valibot");
+var dynamoDbStream = (table) => {
+  const marshall = () => (0, import_valibot7.transform)((0, import_valibot7.unknown)(), (value) => table.unmarshall(value));
+  return (0, import_valibot7.transform)(
+    (0, import_valibot7.object)(
+      {
+        Records: (0, import_valibot7.array)(
+          (0, import_valibot7.object)({
+            eventName: (0, import_valibot7.picklist)(["MODIFY", "INSERT", "REMOVE"]),
+            dynamodb: (0, import_valibot7.object)({
+              Keys: marshall(),
+              OldImage: (0, import_valibot7.optional)(marshall()),
+              NewImage: (0, import_valibot7.optional)(marshall())
+            })
+          })
+        )
+      },
+      "Invalid DynamoDB Stream input"
+    ),
+    (input) => {
+      return input.Records.map((record) => {
+        const item = record;
+        return {
+          event: record.eventName.toLowerCase(),
+          keys: item.dynamodb.Keys,
+          old: item.dynamodb.OldImage,
+          new: item.dynamodb.NewImage
+        };
+      });
+    }
+  );
+};
+
 // src/validation/positive.ts
 var import_big_float2 = require("@awsless/big-float");
-var import_valibot5 = require("valibot");
+var import_valibot8 = require("valibot");
 function positive(error) {
   return (input) => {
-    return (0, import_big_float2.gt)(input, import_big_float2.ZERO) ? (0, import_valibot5.getOutput)(input) : (0, import_valibot5.getPipeIssues)("positive", error ?? "Invalid positive number", input);
+    return (0, import_big_float2.gt)(input, import_big_float2.ZERO) ? (0, import_valibot8.getOutput)(input) : (0, import_valibot8.getPipeIssues)("positive", error ?? "Invalid positive number", input);
   };
 }
 
 // src/validation/precision.ts
 var import_big_float3 = require("@awsless/big-float");
-var import_valibot6 = require("valibot");
+var import_valibot9 = require("valibot");
 function precision(decimals, error) {
   return (input) => {
     const big = new import_big_float3.BigFloat(input.toString());
-    return -big.exponent <= decimals ? (0, import_valibot6.getOutput)(input) : (0, import_valibot6.getPipeIssues)("precision", error ?? `Invalid ${decimals} precision number`, input);
+    return -big.exponent <= decimals ? (0, import_valibot9.getOutput)(input) : (0, import_valibot9.getPipeIssues)("precision", error ?? `Invalid ${decimals} precision number`, input);
   };
 }
 
 // src/validation/unique.ts
-var import_valibot7 = require("valibot");
+var import_valibot10 = require("valibot");
 function unique(compare = (a, b) => a === b, error) {
   return (input) => {
     for (const x in input) {
       for (const y in input) {
         if (x !== y && compare(input[x], input[y])) {
-          return (0, import_valibot7.getPipeIssues)("unique", error ?? "None unique array", input);
+          return (0, import_valibot10.getPipeIssues)("unique", error ?? "None unique array", input);
         }
       }
     }
-    return (0, import_valibot7.getOutput)(input);
+    return (0, import_valibot10.getOutput)(input);
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   bigfloat,
   date,
+  dynamoDbStream,
   json,
   positive,
   precision,
+  snsTopic,
+  sqsQueue,
   unique,
   uuid,
   ...require("valibot")

package/dist/index.d.cts

@@ -1,7 +1,8 @@
-import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, PipeResult } from 'valibot';
+import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, UnknownSchema, Input, PipeResult } from 'valibot';
 export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
+import { TableDefinition, PrimaryKey } from '@awsless/dynamodb';
 
 type JsonSchema<T extends BaseSchema> = SchemaWithTransform<StringSchema, Output<T>>;
 declare const json: <T extends BaseSchema<any, any>>(schema: T) => JsonSchema<T>;
@@ -20,10 +21,44 @@ declare function date(error?: ErrorMessage, pipe?: Pipe<Date>): DateSchema;
 type UuidSchema = SchemaWithTransform<StringSchema | BaseSchema<UUID>, UUID>;
 declare const uuid: () => UuidSchema;
 
+type SqsQueueSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+    Records: {
+        body: string | Input<S>;
+    }[];
+}, Output<S>[]>;
+declare const sqsQueue: <S extends BaseSchema<any, any> = UnknownSchema<unknown>>(body?: S | undefined) => SqsQueueSchema<S>;
+
+type SnsTopicSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+    Records: {
+        Sns: {
+            Message: string | Input<S>;
+        };
+    }[];
+}, Output<S>[]>;
+declare const snsTopic: <S extends BaseSchema<any, any> = UnknownSchema<unknown>>(body?: S | undefined) => SnsTopicSchema<S>;
+
+type EventName = 'MODIFY' | 'INSERT' | 'REMOVE';
+type DynamoDBStreamSchema<T extends TableDefinition<any, any, any, any>> = BaseSchema<{
+    Records: {
+        eventName: EventName;
+        dynamodb: {
+            Keys: unknown;
+            OldImage?: unknown;
+            NewImage?: unknown;
+        };
+    }[];
+}, {
+    event: Lowercase<EventName>;
+    keys: PrimaryKey<T>;
+    old?: T['schema']['OUTPUT'];
+    new?: T['schema']['OUTPUT'];
+}[]>;
+declare const dynamoDbStream: <T extends TableDefinition<any, any, any, any>>(table: T) => DynamoDBStreamSchema<T>;
+
 declare function positive<T extends BigFloat | number>(error?: ErrorMessage): (input: T) => PipeResult<T>;
 
 declare function precision<T extends BigFloat | number>(decimals: number, error?: ErrorMessage): (input: T) => PipeResult<T>;
 
 declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, error?: ErrorMessage): (input: T) => PipeResult<T>;
 
-export { bigfloat, date, json, positive, precision, unique, uuid };
+export { BigFloatSchema, DateSchema, DynamoDBStreamSchema, JsonSchema, SnsTopicSchema, SqsQueueSchema, UuidSchema, bigfloat, date, dynamoDbStream, json, positive, precision, snsTopic, sqsQueue, unique, uuid };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, PipeResult } from 'valibot';
+import { BaseSchema, SchemaWithTransform, StringSchema, Output, Pipe, ErrorMessage, UnknownSchema, Input, PipeResult } from 'valibot';
 export * from 'valibot';
 import { BigFloat } from '@awsless/big-float';
 import { UUID } from 'crypto';
+import { TableDefinition, PrimaryKey } from '@awsless/dynamodb';
 
 type JsonSchema<T extends BaseSchema> = SchemaWithTransform<StringSchema, Output<T>>;
 declare const json: <T extends BaseSchema<any, any>>(schema: T) => JsonSchema<T>;
@@ -20,10 +21,44 @@ declare function date(error?: ErrorMessage, pipe?: Pipe<Date>): DateSchema;
 type UuidSchema = SchemaWithTransform<StringSchema | BaseSchema<UUID>, UUID>;
 declare const uuid: () => UuidSchema;
 
+type SqsQueueSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+    Records: {
+        body: string | Input<S>;
+    }[];
+}, Output<S>[]>;
+declare const sqsQueue: <S extends BaseSchema<any, any> = UnknownSchema<unknown>>(body?: S | undefined) => SqsQueueSchema<S>;
+
+type SnsTopicSchema<S extends BaseSchema = UnknownSchema> = BaseSchema<Input<S> | Input<S>[] | {
+    Records: {
+        Sns: {
+            Message: string | Input<S>;
+        };
+    }[];
+}, Output<S>[]>;
+declare const snsTopic: <S extends BaseSchema<any, any> = UnknownSchema<unknown>>(body?: S | undefined) => SnsTopicSchema<S>;
+
+type EventName = 'MODIFY' | 'INSERT' | 'REMOVE';
+type DynamoDBStreamSchema<T extends TableDefinition<any, any, any, any>> = BaseSchema<{
+    Records: {
+        eventName: EventName;
+        dynamodb: {
+            Keys: unknown;
+            OldImage?: unknown;
+            NewImage?: unknown;
+        };
+    }[];
+}, {
+    event: Lowercase<EventName>;
+    keys: PrimaryKey<T>;
+    old?: T['schema']['OUTPUT'];
+    new?: T['schema']['OUTPUT'];
+}[]>;
+declare const dynamoDbStream: <T extends TableDefinition<any, any, any, any>>(table: T) => DynamoDBStreamSchema<T>;
+
 declare function positive<T extends BigFloat | number>(error?: ErrorMessage): (input: T) => PipeResult<T>;
 
 declare function precision<T extends BigFloat | number>(decimals: number, error?: ErrorMessage): (input: T) => PipeResult<T>;
 
 declare function unique<T extends any[]>(compare?: (a: T[number], b: T[number]) => boolean, error?: ErrorMessage): (input: T) => PipeResult<T>;
 
-export { bigfloat, date, json, positive, precision, unique, uuid };
+export { BigFloatSchema, DateSchema, DynamoDBStreamSchema, JsonSchema, SnsTopicSchema, SqsQueueSchema, UuidSchema, bigfloat, date, dynamoDbStream, json, positive, precision, snsTopic, sqsQueue, unique, uuid };

package/dist/index.js

@@ -89,6 +89,92 @@ var uuid = () => {
   return transform4(string4([base2()]), (v) => v);
 };
 
+// src/schema/aws/sqs-queue.ts
+import { array, object as object2, transform as transform5, union as union3, unknown } from "valibot";
+var sqsQueue = (body) => {
+  const schema = body ?? unknown();
+  return union3(
+    [
+      transform5(schema, (input) => [input]),
+      array(schema),
+      transform5(
+        object2({
+          Records: array(
+            object2({
+              body: json(schema)
+            })
+          )
+        }),
+        (input) => input.Records.map((record) => {
+          return record.body;
+        })
+      )
+    ],
+    "Invalid SQS Queue input"
+  );
+};
+
+// src/schema/aws/sns-topic.ts
+import { array as array2, object as object3, transform as transform6, union as union4, unknown as unknown2 } from "valibot";
+var snsTopic = (body) => {
+  const schema = body ?? unknown2();
+  return union4(
+    [
+      transform6(schema, (input) => [input]),
+      array2(schema),
+      transform6(
+        object3({
+          Records: array2(
+            object3({
+              Sns: object3({
+                Message: json(schema)
+              })
+            })
+          )
+        }),
+        (input) => input.Records.map((record) => {
+          return record.Sns.Message;
+        })
+      )
+    ],
+    "Invalid SNS Topic input"
+  );
+};
+
+// src/schema/aws/dynamodb-stream.ts
+import { array as array3, object as object4, optional, picklist, transform as transform7, unknown as unknown3 } from "valibot";
+var dynamoDbStream = (table) => {
+  const marshall = () => transform7(unknown3(), (value) => table.unmarshall(value));
+  return transform7(
+    object4(
+      {
+        Records: array3(
+          object4({
+            eventName: picklist(["MODIFY", "INSERT", "REMOVE"]),
+            dynamodb: object4({
+              Keys: marshall(),
+              OldImage: optional(marshall()),
+              NewImage: optional(marshall())
+            })
+          })
+        )
+      },
+      "Invalid DynamoDB Stream input"
+    ),
+    (input) => {
+      return input.Records.map((record) => {
+        const item = record;
+        return {
+          event: record.eventName.toLowerCase(),
+          keys: item.dynamodb.Keys,
+          old: item.dynamodb.OldImage,
+          new: item.dynamodb.NewImage
+        };
+      });
+    }
+  );
+};
+
 // src/validation/positive.ts
 import { ZERO, gt } from "@awsless/big-float";
 import { getOutput as getOutput2, getPipeIssues as getPipeIssues2 } from "valibot";
@@ -125,9 +211,12 @@ function unique(compare = (a, b) => a === b, error) {
 export {
   bigfloat,
   date,
+  dynamoDbStream,
   json,
   positive,
   precision,
+  snsTopic,
+  sqsQueue,
   unique,
   uuid
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awsless/validate",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -24,10 +24,12 @@
     }
   },
   "peerDependencies": {
-    "@awsless/big-float": "^0.0.4"
+    "@awsless/big-float": "^0.0.4",
+    "@awsless/dynamodb": "^0.0.40"
   },
   "devDependencies": {
-    "@awsless/big-float": "^0.0.4"
+    "@awsless/big-float": "^0.0.4",
+    "@awsless/dynamodb": "^0.0.40"
   },
   "dependencies": {
     "valibot": "^0.20.1"