monorise 0.0.1

package/dist/sst/.sst/platform/src/components/aws/providers/vector-table.d.ts

@@ -0,0 +1,12 @@
+import { CustomResourceOptions, Input, dynamic } from "@pulumi/pulumi";
+export interface PostgresTableInputs {
+    clusterArn: Input<string>;
+    secretArn: Input<string>;
+    databaseName: Input<string>;
+    tableName: Input<string>;
+    dimension: Input<number>;
+}
+export declare class VectorTable extends dynamic.Resource {
+    constructor(name: string, args: PostgresTableInputs, opts?: CustomResourceOptions);
+}
+//# sourceMappingURL=vector-table.d.ts.map

package/dist/sst/.sst/platform/src/components/aws/providers/vector-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-table.d.ts","sourceRoot":"","sources":["../../../../../../../.sst/platform/src/components/aws/providers/vector-table.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAGvE,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5B,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED,qBAAa,WAAY,SAAQ,OAAO,CAAC,QAAQ;gBAE7C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,mBAAmB,EACzB,IAAI,CAAC,EAAE,qBAAqB;CAS/B"}

package/dist/sst/.sst/platform/src/components/aws/queue-lambda-subscriber.d.ts

@@ -0,0 +1,48 @@
+import { ComponentResourceOptions, Input, Output } from "@pulumi/pulumi";
+import { Component } from "../component";
+import { Function, FunctionArgs } from "./function";
+import { QueueSubscriberArgs } from "./queue";
+export interface Args extends QueueSubscriberArgs {
+    /**
+     * The queue to use.
+     */
+    queue: Input<{
+        /**
+         * The ARN of the queue.
+         */
+        arn: Input<string>;
+    }>;
+    /**
+     * The subscriber function.
+     */
+    subscriber: Input<string | FunctionArgs>;
+}
+/**
+ * The `QueueLambdaSubscriber` component is internally used by the `Queue` component to
+ * add a consumer to [Amazon SQS](https://aws.amazon.com/sqs/).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `subscribe` method of the `Queue` component.
+ */
+export declare class QueueLambdaSubscriber extends Component {
+    private readonly fn;
+    private readonly eventSourceMapping;
+    constructor(name: string, args: Args, opts?: ComponentResourceOptions);
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Lambda function that'll be notified.
+         */
+        readonly function: Output<Function>;
+        /**
+         * The Lambda event source mapping.
+         */
+        eventSourceMapping: import("@pulumi/aws/lambda/eventSourceMapping").EventSourceMapping;
+    };
+}
+//# sourceMappingURL=queue-lambda-subscriber.d.ts.map

package/dist/sst/.sst/platform/src/components/aws/queue-lambda-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-lambda-subscriber.d.ts","sourceRoot":"","sources":["../../../../../../.sst/platform/src/components/aws/queue-lambda-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,KAAK,EACL,MAAM,EAEP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAa,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAM9C,MAAM,WAAW,IAAK,SAAQ,mBAAmB;IAC/C;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;QACX;;WAEG;QACH,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KACpB,CAAC,CAAC;IACH;;OAEG;IACH,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA4B;gBAEnD,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,wBAAwB;IAkErE;;OAEG;IACH,IAAW,KAAK;QAGZ;;WAEG;;QAIH;;WAEG;;MAGN;CACF"}

package/dist/sst/.sst/platform/src/components/aws/queue.d.ts

@@ -0,0 +1,485 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Component, Transform } from "../component";
+import { Link } from "../link";
+import type { Input } from "../input";
+import { FunctionArgs, FunctionArn } from "./function";
+import { QueueLambdaSubscriber } from "./queue-lambda-subscriber";
+import { lambda, sqs } from "@pulumi/aws";
+import { DurationHours, DurationMinutes } from "../duration";
+export interface QueueArgs {
+    /**
+     * FIFO or _first-in-first-out_ queues are designed to guarantee that messages are processed exactly once and in the order that they are sent.
+     *
+     * :::caution
+     * Changing a standard queue to a FIFO queue (or the other way around) will cause the queue to be destroyed and recreated.
+     * :::
+     *
+     * @default `false`
+     * @example
+     * ```js
+     * {
+     *   fifo: true
+     * }
+     * ```
+     *
+     * By default, content based deduplication is disabled. You can enable it by configuring
+     * the `fifo` property.
+     *
+     * ```js
+     * {
+     *   fifo: {
+     *     contentBasedDeduplication: true
+     *   }
+     * }
+     * ```
+     */
+    fifo?: Input<boolean | {
+        /**
+         * Content-based deduplication automatically generates a deduplication ID by hashing
+         * the message body to prevent duplicate message delivery.
+         *
+         * @default `false`
+         */
+        contentBasedDeduplication?: Input<boolean>;
+    }>;
+    /**
+     * The period of time which the delivery of all messages in the queue is delayed.
+     *
+     * This can range from 0 seconds to 900 seconds (15 minutes).
+     *
+     * @default `"0 seconds"`
+     * @example
+     * ```js
+     * {
+     *   delay: "10 seconds"
+     * }
+     * ```
+     */
+    delay?: Input<DurationMinutes>;
+    /**
+     * Visibility timeout is a period of time during which a message is temporarily
+     * invisible to other consumers after a consumer has retrieved it from the queue.
+     * This mechanism prevents other consumers from processing the same message
+     * concurrently, ensuring that each message is processed only once.
+     *
+     * This timeout can range from 0 seconds to 12 hours.
+     *
+     * @default `"30 seconds"`
+     * @example
+     * ```js
+     * {
+     *   visibilityTimeout: "1 hour"
+     * }
+     * ```
+     */
+    visibilityTimeout?: Input<DurationHours>;
+    /**
+     * Optionally add a dead-letter queue or DLQ for this queue.
+     *
+     * A dead-letter queue is used to store messages that can't be processed successfully by the
+     * subscriber function after the `retry` limit is reached.
+     *
+     * This takes either the ARN of the dead-letter queue or an object to configure how the
+     * dead-letter queue is used.
+     *
+     * @example
+     * For example, here's how you can create a dead-letter queue and link it to the main queue.
+     *
+     * ```ts title="sst.config.ts" {4}
+     * const deadLetterQueue = new sst.aws.Queue("MyDLQ");
+     *
+     * new sst.aws.Queue("MyQueue", {
+     *   dlq: deadLetterQueue.arn,
+     * });
+     * ```
+     *
+     * By default, the main queue will retry processing the message 3 times before sending it to the dead-letter queue. You can customize this.
+     *
+     * ```ts title="sst.config.ts" {3}
+     * new sst.aws.Queue("MyQueue", {
+     *   dlq: {
+     *     retry: 5,
+     *     queue: deadLetterQueue.arn,
+     *   }
+     * });
+     * ```
+     */
+    dlq?: Input<string | {
+        /**
+         * The ARN of the dead-letter queue.
+         */
+        queue: Input<string>;
+        /**
+         * The number of times the main queue will retry the message before sending it to the dead-letter queue.
+         * @default `3`
+         */
+        retry: Input<number>;
+    }>;
+    /**
+     * [Transform](/docs/components#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the SQS Queue resource.
+         */
+        queue?: Transform<sqs.QueueArgs>;
+    };
+}
+export interface QueueSubscriberArgs {
+    /**
+     * Filter the records that'll be processed by the `subscriber` function.
+     *
+     * :::tip
+     * You can pass in up to 5 different filters.
+     * :::
+     *
+     * You can pass in up to 5 different filter policies. These will logically ORed together. Meaning that if any single policy matches, the record will be processed. Learn more about the [filter rule syntax](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventfiltering.html#filtering-syntax).
+     *
+     * @example
+     * For example, if you Queue contains records in this JSON format.
+     * ```js
+     * {
+     *   RecordNumber: 0000,
+     *   RequestCode: "AAAA",
+     *   TimeStamp: "yyyy-mm-ddThh:mm:ss"
+     * }
+     * ```
+     *
+     * To process only those records where the `RequestCode` is `BBBB`.
+  
+     * ```js
+     * {
+     *   filters: [
+     *     {
+     *       body: {
+     *         RequestCode: ["BBBB"]
+     *       }
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * And to process only those records where `RecordNumber` greater than `9999`.
+     *
+     * ```js
+     * {
+     *   filters: [
+     *     {
+     *       body: {
+     *         RecordNumber: [{ numeric: [ ">", 9999 ] }]
+     *       }
+     *     }
+     *   ]
+     * }
+     * ```
+     */
+    filters?: Input<Input<Record<string, any>>[]>;
+    /**
+     * Configure batch processing options for the consumer function.
+     * @default `{size: 10, window: "20 seconds", partialResponses: false}`
+     */
+    batch?: Input<{
+        /**
+         * The maximum number of events that will be processed together in a single invocation
+         * of the consumer function.
+         *
+         * Value must be between 1 and 10000.
+         *
+         * :::note
+         * When `size` is set to a value greater than 10, `window` must be set to at least `1 second`.
+         * :::
+         *
+         * @default `10`
+         * @example
+         * Set batch size to 1. This will process events individually.
+         * ```js
+         * {
+         *   batch: {
+         *     size: 1
+         *   }
+         * }
+         * ```
+         */
+        size?: Input<number>;
+        /**
+         * The maximum amount of time to wait for collecting events before sending the batch to
+         * the consumer function, even if the batch size hasn't been reached.
+         *
+         * Value must be between 0 seconds and 5 minutes (300 seconds).
+         * @default `"0 seconds"`
+         * @example
+         * ```js
+         * {
+         *   batch: {
+         *     window: "20 seconds"
+         *   }
+         * }
+         * ```
+         */
+        window?: Input<DurationMinutes>;
+        /**
+         * Whether to return partial successful responses for a batch.
+         *
+         * Enables reporting of individual message failures in a batch. When enabled, only failed
+         * messages become visible in the queue again, preventing unnecessary reprocessing of
+         * successful messages.
+         *
+         * The handler function must return a response with failed message IDs.
+         *
+         * :::note
+         * Ensure your Lambda function is updated to handle `batchItemFailures` responses when
+         * enabling this option.
+         * :::
+         *
+         * Read more about [partial batch responses](https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html#services-sqs-batchfailurereporting).
+         * @default `false`
+         * @example
+         * Enable partial responses.
+         * ```js
+         * {
+         *   batch: {
+         *     partialResponses: true
+         *   }
+         * }
+         * ```
+         *
+         * For a batch of messages (id1, id2, id3, id4, id5), if id2 and id4 fail:
+         * ```json
+         * {
+         *   "batchItemFailures": [
+         *         {
+         *             "itemIdentifier": "id2"
+         *         },
+         *         {
+         *             "itemIdentifier": "id4"
+         *         }
+         *     ]
+         * }
+         * ```
+         *
+         * This makes only id2 and id4 visible again in the queue.
+         */
+        partialResponses?: Input<boolean>;
+    }>;
+    /**
+     * [Transform](/docs/components#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the Lambda Event Source Mapping resource.
+         */
+        eventSourceMapping?: Transform<lambda.EventSourceMappingArgs>;
+    };
+}
+/**
+ * The `Queue` component lets you add a serverless queue to your app. It uses [Amazon SQS](https://aws.amazon.com/sqs/).
+ *
+ * @example
+ *
+ * #### Create a queue
+ *
+ * ```ts title="sst.config.ts"
+ * const queue = new sst.aws.Queue("MyQueue");
+ * ```
+ *
+ * #### Make it a FIFO queue
+ *
+ * You can optionally make it a FIFO queue.
+ *
+ * ```ts {2} title="sst.config.ts"
+ * new sst.aws.Queue("MyQueue", {
+ *   fifo: true
+ * });
+ * ```
+ *
+ * #### Add a subscriber
+ *
+ * ```ts title="sst.config.ts"
+ * queue.subscribe("src/subscriber.handler");
+ * ```
+ *
+ * #### Link the queue to a resource
+ *
+ * You can link the queue to other resources, like a function or your Next.js app.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [queue]
+ * });
+ * ```
+ *
+ * Once linked, you can send messages to the queue from your function code.
+ *
+ * ```ts title="app/page.tsx" {1,7}
+ * import { Resource } from "sst";
+ * import { SQSClient, SendMessageCommand } from "@aws-sdk/client-sqs";
+ *
+ * const sqs = new SQSClient({});
+ *
+ * await sqs.send(new SendMessageCommand({
+ *   QueueUrl: Resource.MyQueue.url,
+ *   MessageBody: "Hello from Next.js!"
+ * }));
+ * ```
+ */
+export declare class Queue extends Component implements Link.Linkable {
+    private constructorName;
+    private constructorOpts;
+    private queue;
+    private isSubscribed;
+    constructor(name: string, args?: QueueArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ARN of the SQS Queue.
+     */
+    get arn(): Output<string>;
+    /**
+     * The SQS Queue URL.
+     */
+    get url(): Output<string>;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Amazon SQS Queue.
+         */
+        queue: import("@pulumi/aws/sqs/queue").Queue;
+    };
+    /**
+     * Subscribe to this queue.
+     *
+     * @param subscriber The function that'll be notified.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe("src/subscriber.handler");
+     * ```
+     *
+     * Add a filter to the subscription.
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe("src/subscriber.handler", {
+     *   filters: [
+     *     {
+     *       body: {
+     *         RequestCode: ["BBBB"]
+     *       }
+     *     }
+     *   ]
+     * });
+     * ```
+     *
+     * Customize the subscriber function.
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe({
+     *   handler: "src/subscriber.handler",
+     *   timeout: "60 seconds"
+     * });
+     * ```
+     *
+     * Or pass in the ARN of an existing Lambda function.
+     *
+     * ```js title="sst.config.ts"
+     * queue.subscribe("arn:aws:lambda:us-east-1:123456789012:function:my-function");
+     * ```
+     */
+    subscribe(subscriber: Input<string | FunctionArgs | FunctionArn>, args?: QueueSubscriberArgs, opts?: ComponentResourceOptions): Output<QueueLambdaSubscriber>;
+    /**
+     * Subscribe to an SQS Queue that was not created in your app.
+     *
+     * @param queueArn The ARN of the SQS Queue to subscribe to.
+     * @param subscriber The function that'll be notified.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * For example, let's say you have an existing SQS Queue with the following ARN.
+     *
+     * ```js title="sst.config.ts"
+     * const queueArn = "arn:aws:sqs:us-east-1:123456789012:MyQueue";
+     * ```
+     *
+     * You can subscribe to it by passing in the ARN.
+     *
+     * ```js title="sst.config.ts"
+     * sst.aws.Queue.subscribe(queueArn, "src/subscriber.handler");
+     * ```
+     *
+     * Add a filter to the subscription.
+     *
+     * ```js title="sst.config.ts"
+     * sst.aws.Queue.subscribe(queueArn, "src/subscriber.handler", {
+     *   filters: [
+     *     {
+     *       body: {
+     *         RequestCode: ["BBBB"]
+     *       }
+     *     }
+     *   ]
+     * });
+     * ```
+     *
+     * Customize the subscriber function.
+     *
+     * ```js title="sst.config.ts"
+     * sst.aws.Queue.subscribe(queueArn, {
+     *   handler: "src/subscriber.handler",
+     *   timeout: "60 seconds"
+     * });
+     * ```
+     */
+    static subscribe(queueArn: Input<string>, subscriber: Input<string | FunctionArgs | FunctionArn>, args?: QueueSubscriberArgs, opts?: ComponentResourceOptions): Output<QueueLambdaSubscriber>;
+    private static _subscribeFunction;
+    /**
+     * Reference an existing SQS Queue with its queue URL. This is useful when you create a
+     * queue in one stage and want to share it in another stage. It avoids having to create
+     * a new queue in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share SQS queues across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param queueUrl The URL of the existing SQS Queue.
+     * @param opts? Resource options.
+     *
+     * @example
+     * Imagine you create a queue in the `dev` stage. And in your personal stage `frank`,
+     * instead of creating a new queue, you want to share the queue from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const queue = $app.stage === "frank"
+     *   ? sst.aws.Queue.get("MyQueue", "https://sqs.us-east-1.amazonaws.com/123456789012/MyQueue")
+     *   : new sst.aws.Queue("MyQueue");
+     * ```
+     *
+     * Here `https://sqs.us-east-1.amazonaws.com/123456789012/MyQueue` is the URL of the queue
+     * created in the `dev` stage. You can find this by outputting the queue URL in the `dev`
+     * stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return queue.url;
+     * ```
+     */
+    static get(name: string, queueUrl: Input<string>, opts?: ComponentResourceOptions): Queue;
+    /** @internal */
+    getSSTLink(): {
+        properties: {
+            url: Output<string>;
+        };
+        include: {
+            effect?: "allow" | "deny" | undefined;
+            actions: string[];
+            resources: Input<Input<string>[]>;
+            type: "aws.permission";
+        }[];
+    };
+    /** @internal */
+    static createPolicy(name: string, arn: Output<string>, opts?: ComponentResourceOptions): import("@pulumi/aws/sqs/queuePolicy").QueuePolicy;
+}
+//# sourceMappingURL=queue.d.ts.map

package/dist/sst/.sst/platform/src/components/aws/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../../../../../../.sst/platform/src/components/aws/queue.ts"],"names":[],"mappings":"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"}