@jaypie/constructs 1.2.4 → 1.2.6

package/dist/cjs/JaypieDynamoDb.d.ts

@@ -0,0 +1,115 @@
+import { Construct } from "constructs";
+import { RemovalPolicy } from "aws-cdk-lib";
+import * as dynamodb from "aws-cdk-lib/aws-dynamodb";
+export interface JaypieDynamoDbProps extends Omit<dynamodb.TablePropsV2, "globalSecondaryIndexes" | "partitionKey" | "sortKey"> {
+    /**
+     * Configure GSIs for the table.
+     * - `undefined` or `true`: Creates all five Jaypie GSIs (Alias, Class, Ou, Type, Xid)
+     * - `false`: No GSIs
+     * - Array: Use the specified GSIs
+     */
+    globalSecondaryIndexes?: boolean | dynamodb.GlobalSecondaryIndexPropsV2[];
+    /**
+     * Partition key attribute definition.
+     * @default { name: "model", type: AttributeType.STRING }
+     */
+    partitionKey?: dynamodb.Attribute;
+    /**
+     * Optional project identifier for tagging
+     */
+    project?: string;
+    /**
+     * Optional role tag for the table
+     */
+    roleTag?: string;
+    /**
+     * Optional service identifier for tagging
+     */
+    service?: string;
+    /**
+     * Sort key attribute definition.
+     * @default { name: "id", type: AttributeType.STRING }
+     */
+    sortKey?: dynamodb.Attribute;
+    /**
+     * Optional vendor tag for the table
+     */
+    vendorTag?: string;
+}
+/**
+ * DynamoDB table with Jaypie single-table design patterns.
+ *
+ * Creates a table with:
+ * - Partition key: `model` (String)
+ * - Sort key: `id` (String)
+ * - Billing: PAY_PER_REQUEST (on-demand)
+ * - Removal policy: RETAIN in production, DESTROY otherwise
+ * - Five GSIs for different access patterns (can be overridden)
+ *
+ * @example
+ * // Shorthand: tableName becomes "myApp", construct id is "JaypieDynamoDb-myApp"
+ * const table = new JaypieDynamoDb(this, "myApp");
+ *
+ * @example
+ * // Full configuration
+ * const table = new JaypieDynamoDb(this, "MyTable", {
+ *   tableName: "custom-table-name",
+ *   globalSecondaryIndexes: [], // Disable GSIs
+ * });
+ *
+ * @example
+ * // Use only specific GSIs
+ * const table = new JaypieDynamoDb(this, "MyTable", {
+ *   globalSecondaryIndexes: [
+ *     JaypieDynamoDb.GlobalSecondaryIndex.Ou,
+ *     JaypieDynamoDb.GlobalSecondaryIndex.Type,
+ *   ],
+ * });
+ */
+export declare class JaypieDynamoDb extends Construct implements dynamodb.ITableV2 {
+    /**
+     * Individual GSI definitions for Jaypie single-table design
+     */
+    static readonly GlobalSecondaryIndex: {
+        readonly Alias: dynamodb.GlobalSecondaryIndexPropsV2;
+        readonly Class: dynamodb.GlobalSecondaryIndexPropsV2;
+        readonly Ou: dynamodb.GlobalSecondaryIndexPropsV2;
+        readonly Type: dynamodb.GlobalSecondaryIndexPropsV2;
+        readonly Xid: dynamodb.GlobalSecondaryIndexPropsV2;
+    };
+    /**
+     * Array of all default Jaypie GSI definitions
+     */
+    static readonly GlobalSecondaryIndexes: dynamodb.GlobalSecondaryIndexPropsV2[];
+    private readonly _table;
+    constructor(scope: Construct, id: string, props?: JaypieDynamoDbProps);
+    /**
+     * The underlying DynamoDB TableV2 construct
+     */
+    get table(): dynamodb.TableV2;
+    get env(): import("aws-cdk-lib").ResourceEnvironment;
+    get stack(): import("aws-cdk-lib").Stack;
+    get tableArn(): string;
+    get tableId(): string | undefined;
+    get tableName(): string;
+    get tableStreamArn(): string | undefined;
+    get encryptionKey(): import("aws-cdk-lib/aws-kms").IKey | undefined;
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+    grant(grantee: import("aws-cdk-lib/aws-iam").IGrantable, ...actions: string[]): import("aws-cdk-lib/aws-iam").Grant;
+    grantFullAccess(grantee: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    grantReadData(grantee: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    grantReadWriteData(grantee: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    grantStream(grantee: import("aws-cdk-lib/aws-iam").IGrantable, ...actions: string[]): import("aws-cdk-lib/aws-iam").Grant;
+    grantStreamRead(grantee: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    grantTableListStreams(grantee: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    grantWriteData(grantee: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    metric(metricName: string, props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricConditionalCheckFailedRequests(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricConsumedReadCapacityUnits(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricConsumedWriteCapacityUnits(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricSuccessfulRequestLatency(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricSystemErrorsForOperations(props?: dynamodb.SystemErrorsForOperationsMetricOptions): import("aws-cdk-lib/aws-cloudwatch").IMetric;
+    metricThrottledRequests(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricThrottledRequestsForOperations(props?: dynamodb.OperationsMetricOptions): import("aws-cdk-lib/aws-cloudwatch").IMetric;
+    metricUserErrors(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+}

package/dist/cjs/JaypieLambda.d.ts

@@ -20,8 +20,10 @@ export interface JaypieLambdaProps {
     description?: string;
     /**
      * DynamoDB tables to grant read/write access to the Lambda function.
+     * Each table is granted read/write access and if exactly one table is provided,
+     * the DYNAMODB_TABLE_NAME environment variable is set to the table name.
      */
-    dynamoTables?: dynamodb.ITable[];
+    tables?: dynamodb.ITable[];
     /**
      * Environment variables for the Lambda function.
      *

package/dist/cjs/JaypieNextJs.d.ts

@@ -22,8 +22,10 @@ export interface JaypieNextjsProps {
     domainName?: string | DomainNameConfig;
     /**
      * DynamoDB tables to grant read/write access to the Next.js server function.
+     * Each table is granted read/write access and if exactly one table is provided,
+     * the DYNAMODB_TABLE_NAME environment variable is set to the table name.
      */
-    dynamoTables?: dynamodb.ITable[];
+    tables?: dynamodb.ITable[];
     /**
      * Environment variables for the Next.js application.
      *

package/dist/cjs/__tests__/JaypieDynamoDb.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/index.cjs

@@ -21,6 +21,7 @@ var awsEvents = require('aws-cdk-lib/aws-events');
 var awsEventsTargets = require('aws-cdk-lib/aws-events-targets');
 var cloudfront = require('aws-cdk-lib/aws-cloudfront');
 var origins = require('aws-cdk-lib/aws-cloudfront-origins');
+var dynamodb = require('aws-cdk-lib/aws-dynamodb');
 var cdkNextjsStandalone = require('cdk-nextjs-standalone');
 var path = require('path');
 var awsCloudtrail = require('aws-cdk-lib/aws-cloudtrail');
@@ -59,6 +60,7 @@ var lambdaEventSources__namespace = /*#__PURE__*/_interopNamespaceDefault(lambda
 var logs__namespace = /*#__PURE__*/_interopNamespaceDefault(logs);
 var cloudfront__namespace = /*#__PURE__*/_interopNamespaceDefault(cloudfront);
 var origins__namespace = /*#__PURE__*/_interopNamespaceDefault(origins);
+var dynamodb__namespace = /*#__PURE__*/_interopNamespaceDefault(dynamodb);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 const CDK$2 = {
@@ -1208,7 +1210,7 @@ class JaypieAppStack extends JaypieStack {
 class JaypieLambda extends constructs.Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { allowAllOutbound, allowPublicSubnet, architecture = lambda__namespace.Architecture.X86_64, code, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, dynamoTables = [], environment: environmentInput, envSecrets = {}, ephemeralStorageSize, filesystem, handler = "index.handler", initialPolicy, layers = [], logGroup, logRetention = CDK$2.LAMBDA.LOG_RETENTION, maxEventAge, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag = CDK$2.ROLE.PROCESSING, runtime = new lambda__namespace.Runtime("nodejs24.x", lambda__namespace.RuntimeFamily.NODEJS, {
+        const { allowAllOutbound, allowPublicSubnet, architecture = lambda__namespace.Architecture.X86_64, code, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, tables = [], environment: environmentInput, envSecrets = {}, ephemeralStorageSize, filesystem, handler = "index.handler", initialPolicy, layers = [], logGroup, logRetention = CDK$2.LAMBDA.LOG_RETENTION, maxEventAge, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag = CDK$2.ROLE.PROCESSING, runtime = new lambda__namespace.Runtime("nodejs24.x", lambda__namespace.RuntimeFamily.NODEJS, {
             supportsInlineCode: true,
         }), runtimeManagementMode, secrets: secretsInput = [], securityGroups, timeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), tracing, vendorTag, vpc, vpcSubnets, } = props;
         // Resolve environment from array or object syntax
@@ -1300,12 +1302,12 @@ class JaypieLambda extends constructs.Construct {
             secret.grantRead(this._lambda);
         });
         // Grant read/write permissions for DynamoDB tables
-        dynamoTables.forEach((table) => {
+        tables.forEach((table) => {
             table.grantReadWriteData(this._lambda);
         });
         // Add table name to environment if there's exactly one table
-        if (dynamoTables.length === 1) {
-            this._lambda.addEnvironment("CDK_ENV_DYNAMO_TABLE", dynamoTables[0].tableName);
+        if (tables.length === 1) {
+            this._lambda.addEnvironment("DYNAMODB_TABLE_NAME", tables[0].tableName);
         }
         // Configure provisioned concurrency if specified
         if (provisionedConcurrentExecutions !== undefined) {
@@ -2295,6 +2297,247 @@ class JaypieDnsRecord extends constructs.Construct {
     }
 }
 
+//
+//
+// Constants
+//
+/**
+ * GSI attribute names used in Jaypie single-table design
+ */
+const GSI_NAMES = {
+    ALIAS: "indexAlias",
+    CLASS: "indexClass",
+    OU: "indexOu",
+    TYPE: "indexType",
+    XID: "indexXid",
+};
+/**
+ * Individual GSI definitions for Jaypie single-table design.
+ * All GSIs use a string partition key and numeric sort key (sequence).
+ */
+const GlobalSecondaryIndex = {
+    Alias: {
+        indexName: GSI_NAMES.ALIAS,
+        partitionKey: {
+            name: GSI_NAMES.ALIAS,
+            type: dynamodb__namespace.AttributeType.STRING,
+        },
+        projectionType: dynamodb__namespace.ProjectionType.ALL,
+        sortKey: { name: "sequence", type: dynamodb__namespace.AttributeType.NUMBER },
+    },
+    Class: {
+        indexName: GSI_NAMES.CLASS,
+        partitionKey: {
+            name: GSI_NAMES.CLASS,
+            type: dynamodb__namespace.AttributeType.STRING,
+        },
+        projectionType: dynamodb__namespace.ProjectionType.ALL,
+        sortKey: { name: "sequence", type: dynamodb__namespace.AttributeType.NUMBER },
+    },
+    Ou: {
+        indexName: GSI_NAMES.OU,
+        partitionKey: { name: GSI_NAMES.OU, type: dynamodb__namespace.AttributeType.STRING },
+        projectionType: dynamodb__namespace.ProjectionType.ALL,
+        sortKey: { name: "sequence", type: dynamodb__namespace.AttributeType.NUMBER },
+    },
+    Type: {
+        indexName: GSI_NAMES.TYPE,
+        partitionKey: { name: GSI_NAMES.TYPE, type: dynamodb__namespace.AttributeType.STRING },
+        projectionType: dynamodb__namespace.ProjectionType.ALL,
+        sortKey: { name: "sequence", type: dynamodb__namespace.AttributeType.NUMBER },
+    },
+    Xid: {
+        indexName: GSI_NAMES.XID,
+        partitionKey: { name: GSI_NAMES.XID, type: dynamodb__namespace.AttributeType.STRING },
+        projectionType: dynamodb__namespace.ProjectionType.ALL,
+        sortKey: { name: "sequence", type: dynamodb__namespace.AttributeType.NUMBER },
+    },
+};
+/**
+ * Array of all default Jaypie GSI definitions.
+ * Used when no globalSecondaryIndexes are provided.
+ */
+const GlobalSecondaryIndexes = [
+    GlobalSecondaryIndex.Alias,
+    GlobalSecondaryIndex.Class,
+    GlobalSecondaryIndex.Ou,
+    GlobalSecondaryIndex.Type,
+    GlobalSecondaryIndex.Xid,
+];
+//
+//
+// Main
+//
+/**
+ * DynamoDB table with Jaypie single-table design patterns.
+ *
+ * Creates a table with:
+ * - Partition key: `model` (String)
+ * - Sort key: `id` (String)
+ * - Billing: PAY_PER_REQUEST (on-demand)
+ * - Removal policy: RETAIN in production, DESTROY otherwise
+ * - Five GSIs for different access patterns (can be overridden)
+ *
+ * @example
+ * // Shorthand: tableName becomes "myApp", construct id is "JaypieDynamoDb-myApp"
+ * const table = new JaypieDynamoDb(this, "myApp");
+ *
+ * @example
+ * // Full configuration
+ * const table = new JaypieDynamoDb(this, "MyTable", {
+ *   tableName: "custom-table-name",
+ *   globalSecondaryIndexes: [], // Disable GSIs
+ * });
+ *
+ * @example
+ * // Use only specific GSIs
+ * const table = new JaypieDynamoDb(this, "MyTable", {
+ *   globalSecondaryIndexes: [
+ *     JaypieDynamoDb.GlobalSecondaryIndex.Ou,
+ *     JaypieDynamoDb.GlobalSecondaryIndex.Type,
+ *   ],
+ * });
+ */
+class JaypieDynamoDb extends constructs.Construct {
+    constructor(scope, id, props = {}) {
+        // Determine if this is shorthand usage: new JaypieDynamoDb(this, "myApp")
+        // In shorthand, id becomes the tableName and construct id is prefixed
+        const isShorthand = !props.tableName && !id.includes("-");
+        const constructId = isShorthand ? `JaypieDynamoDb-${id}` : id;
+        const tableName = props.tableName ?? (isShorthand ? id : undefined);
+        super(scope, constructId);
+        const { billing = dynamodb__namespace.Billing.onDemand(), globalSecondaryIndexes: gsiInput, partitionKey = {
+            name: "model",
+            type: dynamodb__namespace.AttributeType.STRING,
+        }, project, removalPolicy = isProductionEnv()
+            ? cdk.RemovalPolicy.RETAIN
+            : cdk.RemovalPolicy.DESTROY, roleTag = CDK$2.ROLE.STORAGE, service, sortKey = { name: "id", type: dynamodb__namespace.AttributeType.STRING }, vendorTag, ...restProps } = props;
+        // Resolve GSI configuration: undefined/true = all, false = none, array = use as-is
+        const globalSecondaryIndexes = gsiInput === false
+            ? undefined
+            : Array.isArray(gsiInput)
+                ? gsiInput
+                : GlobalSecondaryIndexes;
+        this._table = new dynamodb__namespace.TableV2(this, "Table", {
+            billing,
+            globalSecondaryIndexes,
+            partitionKey,
+            removalPolicy,
+            sortKey,
+            tableName,
+            ...restProps,
+        });
+        // Apply tags
+        if (project) {
+            cdk.Tags.of(this._table).add(CDK$2.TAG.PROJECT, project);
+        }
+        cdk.Tags.of(this._table).add(CDK$2.TAG.ROLE, roleTag);
+        if (service) {
+            cdk.Tags.of(this._table).add(CDK$2.TAG.SERVICE, service);
+        }
+        if (vendorTag) {
+            cdk.Tags.of(this._table).add(CDK$2.TAG.VENDOR, vendorTag);
+        }
+    }
+    //
+    //
+    // Public accessors
+    //
+    /**
+     * The underlying DynamoDB TableV2 construct
+     */
+    get table() {
+        return this._table;
+    }
+    //
+    //
+    // ITableV2 implementation
+    //
+    get env() {
+        return this._table.env;
+    }
+    get stack() {
+        return this._table.stack;
+    }
+    get tableArn() {
+        return this._table.tableArn;
+    }
+    get tableId() {
+        return this._table.tableId;
+    }
+    get tableName() {
+        return this._table.tableName;
+    }
+    get tableStreamArn() {
+        return this._table.tableStreamArn;
+    }
+    get encryptionKey() {
+        return this._table.encryptionKey;
+    }
+    applyRemovalPolicy(policy) {
+        this._table.applyRemovalPolicy(policy);
+    }
+    grant(grantee, ...actions) {
+        return this._table.grant(grantee, ...actions);
+    }
+    grantFullAccess(grantee) {
+        return this._table.grantFullAccess(grantee);
+    }
+    grantReadData(grantee) {
+        return this._table.grantReadData(grantee);
+    }
+    grantReadWriteData(grantee) {
+        return this._table.grantReadWriteData(grantee);
+    }
+    grantStream(grantee, ...actions) {
+        return this._table.grantStream(grantee, ...actions);
+    }
+    grantStreamRead(grantee) {
+        return this._table.grantStreamRead(grantee);
+    }
+    grantTableListStreams(grantee) {
+        return this._table.grantTableListStreams(grantee);
+    }
+    grantWriteData(grantee) {
+        return this._table.grantWriteData(grantee);
+    }
+    metric(metricName, props) {
+        return this._table.metric(metricName, props);
+    }
+    metricConditionalCheckFailedRequests(props) {
+        return this._table.metricConditionalCheckFailedRequests(props);
+    }
+    metricConsumedReadCapacityUnits(props) {
+        return this._table.metricConsumedReadCapacityUnits(props);
+    }
+    metricConsumedWriteCapacityUnits(props) {
+        return this._table.metricConsumedWriteCapacityUnits(props);
+    }
+    metricSuccessfulRequestLatency(props) {
+        return this._table.metricSuccessfulRequestLatency(props);
+    }
+    metricSystemErrorsForOperations(props) {
+        return this._table.metricSystemErrorsForOperations(props);
+    }
+    metricThrottledRequests(props) {
+        return this._table.metricThrottledRequests(props);
+    }
+    metricThrottledRequestsForOperations(props) {
+        return this._table.metricThrottledRequestsForOperations(props);
+    }
+    metricUserErrors(props) {
+        return this._table.metricUserErrors(props);
+    }
+}
+/**
+ * Individual GSI definitions for Jaypie single-table design
+ */
+JaypieDynamoDb.GlobalSecondaryIndex = GlobalSecondaryIndex;
+/**
+ * Array of all default Jaypie GSI definitions
+ */
+JaypieDynamoDb.GlobalSecondaryIndexes = GlobalSecondaryIndexes;
+
 class JaypieEventsRule extends constructs.Construct {
     /**
      * Create a new EventBridge rule that targets a Lambda function
@@ -2700,13 +2943,13 @@ class JaypieNextJs extends constructs.Construct {
             secret.grantRead(nextjs.serverFunction.lambdaFunction);
         });
         // Grant read/write permissions for DynamoDB tables
-        const dynamoTables = props?.dynamoTables || [];
-        dynamoTables.forEach((table) => {
+        const tables = props?.tables || [];
+        tables.forEach((table) => {
             table.grantReadWriteData(nextjs.serverFunction.lambdaFunction);
         });
         // Add table name to environment if there's exactly one table
-        if (dynamoTables.length === 1) {
-            nextjs.serverFunction.lambdaFunction.addEnvironment("CDK_ENV_DYNAMO_TABLE", dynamoTables[0].tableName);
+        if (tables.length === 1) {
+            nextjs.serverFunction.lambdaFunction.addEnvironment("DYNAMODB_TABLE_NAME", tables[0].tableName);
         }
         // Store reference to nextjs for property exposure
         this._nextjs = nextjs;
@@ -3533,6 +3776,7 @@ exports.JaypieDatadogForwarder = JaypieDatadogForwarder;
 exports.JaypieDatadogSecret = JaypieDatadogSecret;
 exports.JaypieDistribution = JaypieDistribution;
 exports.JaypieDnsRecord = JaypieDnsRecord;
+exports.JaypieDynamoDb = JaypieDynamoDb;
 exports.JaypieEnvSecret = JaypieEnvSecret;
 exports.JaypieEventsRule = JaypieEventsRule;
 exports.JaypieExpressLambda = JaypieExpressLambda;