@fjall/components-infrastructure 0.86.0 → 0.87.3

package/dist/lib/patterns/aws/connections.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared connection processor for unified connector interface.
+ *
+ * This module provides the `processConnections` function that handles
+ * both security group rules (IConnectable) and IAM grants (IGrantable)
+ * in a unified way.
+ *
+ * @example
+ * // In ECS service setup
+ * processConnections(
+ *   serviceProps.connections,
+ *   serviceData.taskRole,  // IGrantable for IAM
+ *   service               // IConnectable for security groups
+ * );
+ *
+ * @example
+ * // In Lambda setup
+ * processConnections(
+ *   props.connections,
+ *   this.lambdaFunction,  // IGrantable (execution role)
+ *   this.lambdaFunction   // IConnectable (security group)
+ * );
+ */
+import { type IConnectable } from "aws-cdk-lib/aws-ec2";
+import { type IGrantable } from "aws-cdk-lib/aws-iam";
+import { type ConnectionSpec, type ConnectionResult } from "./interfaces/connector.js";
+/**
+ * Process connections from compute resources to data resources.
+ *
+ * Handles the unified connector interface, dispatching to:
+ * - Security group rules for IConnectable and ISecurityGroupConnector resources
+ * - IAM grants for IStorageConnector, IDynamoDBConnector, and IQueueConnector resources
+ *
+ * @param connections - Array of connection specifications
+ * @param grantee - The IAM grantee (task role, execution role, etc.)
+ * @param connectable - Optional IConnectable for security group rules
+ * @returns Array of connection results
+ *
+ * @example
+ * processConnections(
+ *   [database, { resource: bucket, access: "read" }, queue],
+ *   taskRole,
+ *   service
+ * );
+ */
+export declare function processConnections(connections: ConnectionSpec[], grantee: IGrantable, connectable?: IConnectable): ConnectionResult[];

package/dist/lib/patterns/aws/connections.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Shared connection processor for unified connector interface.
+ *
+ * This module provides the `processConnections` function that handles
+ * both security group rules (IConnectable) and IAM grants (IGrantable)
+ * in a unified way.
+ *
+ * @example
+ * // In ECS service setup
+ * processConnections(
+ *   serviceProps.connections,
+ *   serviceData.taskRole,  // IGrantable for IAM
+ *   service               // IConnectable for security groups
+ * );
+ *
+ * @example
+ * // In Lambda setup
+ * processConnections(
+ *   props.connections,
+ *   this.lambdaFunction,  // IGrantable (execution role)
+ *   this.lambdaFunction   // IConnectable (security group)
+ * );
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processConnections = processConnections;
+const connector_js_1 = require("./interfaces/connector.js");
+/** Default access levels for each connector type. */
+const DEFAULT_ACCESS = {
+    storage: "readWrite",
+    dynamodb: "readWrite",
+    queue: "full"
+};
+/** Grant storage access based on access level. */
+function processStorageConnection(connector, grantee, access) {
+    switch (access) {
+        case "read":
+            return connector.grantRead(grantee);
+        case "write":
+            return connector.grantWrite(grantee);
+        case "readWrite":
+            return connector.grantReadWrite(grantee);
+    }
+}
+/** Grant DynamoDB access based on access level. */
+function processDynamoDBConnection(connector, grantee, access) {
+    switch (access) {
+        case "read":
+            return connector.grantReadData(grantee);
+        case "write":
+            return connector.grantWriteData(grantee);
+        case "readWrite":
+            return connector.grantReadWriteData(grantee);
+    }
+}
+/** Grant queue access based on access level. */
+function processQueueConnection(connector, grantee, access) {
+    switch (access) {
+        case "send":
+            return connector.grantSendMessages(grantee);
+        case "consume":
+            return connector.grantConsumeMessages(grantee);
+        case "full":
+            return connector.grantFull(grantee);
+    }
+}
+/** Build an IAM connection result. */
+function buildIamResult(connector, grant) {
+    return { resource: connector, grant, connectionType: connector_js_1.CONNECTION_TYPE.IAM };
+}
+/** Build a security group connection result. */
+function buildSecurityGroupResult(resource) {
+    return { resource, connectionType: connector_js_1.CONNECTION_TYPE.SECURITY_GROUP };
+}
+/** Validate and narrow access type for storage/dynamodb connectors. */
+function validateConnectionAccess(access, connectorType, defaultAccess) {
+    if (access === undefined)
+        return defaultAccess;
+    if ((0, connector_js_1.isConnectionAccess)(access))
+        return access;
+    throw new Error(`Invalid access "${access}" for ${connectorType} connector. ` +
+        `Valid values: read, write, readWrite`);
+}
+/** Validate and narrow access type for queue connectors. */
+function validateMessagingAccess(access, defaultAccess) {
+    if (access === undefined)
+        return defaultAccess;
+    if ((0, connector_js_1.isMessagingAccess)(access))
+        return access;
+    throw new Error(`Invalid access "${access}" for queue connector. ` +
+        `Valid values: send, consume, full`);
+}
+/**
+ * Require IConnectable for security group operations.
+ * Throws a descriptive error if not provided.
+ */
+function requireConnectable(connectable, context) {
+    if (!connectable) {
+        throw new Error(`${context} requires an IConnectable to be provided. ` +
+            "Ensure the compute resource (ECS, EC2, Lambda with VPC) implements IConnectable.");
+    }
+}
+/**
+ * Process connections from compute resources to data resources.
+ *
+ * Handles the unified connector interface, dispatching to:
+ * - Security group rules for IConnectable and ISecurityGroupConnector resources
+ * - IAM grants for IStorageConnector, IDynamoDBConnector, and IQueueConnector resources
+ *
+ * @param connections - Array of connection specifications
+ * @param grantee - The IAM grantee (task role, execution role, etc.)
+ * @param connectable - Optional IConnectable for security group rules
+ * @returns Array of connection results
+ *
+ * @example
+ * processConnections(
+ *   [database, { resource: bucket, access: "read" }, queue],
+ *   taskRole,
+ *   service
+ * );
+ */
+function processConnections(connections, grantee, connectable) {
+    return connections.map((spec) => {
+        const { resource, access } = (0, connector_js_1.isConnectionConfig)(spec)
+            ? { resource: spec.resource, access: spec.access }
+            : { resource: spec, access: undefined };
+        // Handle unified connector interface (isConnector now returns AnyConnector)
+        if ((0, connector_js_1.isConnector)(resource)) {
+            switch (resource.connectorType) {
+                case "storage": {
+                    const validAccess = validateConnectionAccess(access, "storage", DEFAULT_ACCESS.storage);
+                    return buildIamResult(resource, processStorageConnection(resource, grantee, validAccess));
+                }
+                case "dynamodb": {
+                    const validAccess = validateConnectionAccess(access, "dynamodb", DEFAULT_ACCESS.dynamodb);
+                    return buildIamResult(resource, processDynamoDBConnection(resource, grantee, validAccess));
+                }
+                case "queue": {
+                    const validAccess = validateMessagingAccess(access, DEFAULT_ACCESS.queue);
+                    return buildIamResult(resource, processQueueConnection(resource, grantee, validAccess));
+                }
+                case "securityGroup":
+                case "relational": {
+                    requireConnectable(connectable, `${resource.connectorType} connector`);
+                    connectable.connections.allowToDefaultPort(resource);
+                    return buildSecurityGroupResult(resource);
+                }
+            }
+        }
+        // Legacy IConnectable path
+        if ((0, connector_js_1.isConnectable)(resource)) {
+            requireConnectable(connectable, "IConnectable resource");
+            connectable.connections.allowToDefaultPort(resource);
+            return buildSecurityGroupResult(resource);
+        }
+        throw new Error("Connection resource must be either an IConnector or IConnectable");
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connections.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/connections.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Shared connection processor for unified connector interface.\n *\n * This module provides the `processConnections` function that handles\n * both security group rules (IConnectable) and IAM grants (IGrantable)\n * in a unified way.\n *\n * @example\n * // In ECS service setup\n * processConnections(\n *   serviceProps.connections,\n *   serviceData.taskRole,  // IGrantable for IAM\n *   service               // IConnectable for security groups\n * );\n *\n * @example\n * // In Lambda setup\n * processConnections(\n *   props.connections,\n *   this.lambdaFunction,  // IGrantable (execution role)\n *   this.lambdaFunction   // IConnectable (security group)\n * );\n */\n\nimport { type IConnectable } from \"aws-cdk-lib/aws-ec2\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\nimport {\n  type ConnectionSpec,\n  type ConnectionResult,\n  type ConnectionAccess,\n  type MessagingAccess,\n  type AnyConnector,\n  type IStorageConnector,\n  type IDynamoDBConnector,\n  type IQueueConnector,\n  CONNECTION_TYPE,\n  isConnectionConfig,\n  isConnector,\n  isConnectable,\n  isConnectionAccess,\n  isMessagingAccess\n} from \"./interfaces/connector.js\";\n\n/** Default access levels for each connector type. */\nconst DEFAULT_ACCESS = {\n  storage: \"readWrite\",\n  dynamodb: \"readWrite\",\n  queue: \"full\"\n} as const;\n\n/** Grant storage access based on access level. */\nfunction processStorageConnection(\n  connector: IStorageConnector,\n  grantee: IGrantable,\n  access: ConnectionAccess\n): Grant {\n  switch (access) {\n    case \"read\":\n      return connector.grantRead(grantee);\n    case \"write\":\n      return connector.grantWrite(grantee);\n    case \"readWrite\":\n      return connector.grantReadWrite(grantee);\n  }\n}\n\n/** Grant DynamoDB access based on access level. */\nfunction processDynamoDBConnection(\n  connector: IDynamoDBConnector,\n  grantee: IGrantable,\n  access: ConnectionAccess\n): Grant {\n  switch (access) {\n    case \"read\":\n      return connector.grantReadData(grantee);\n    case \"write\":\n      return connector.grantWriteData(grantee);\n    case \"readWrite\":\n      return connector.grantReadWriteData(grantee);\n  }\n}\n\n/** Grant queue access based on access level. */\nfunction processQueueConnection(\n  connector: IQueueConnector,\n  grantee: IGrantable,\n  access: MessagingAccess\n): Grant {\n  switch (access) {\n    case \"send\":\n      return connector.grantSendMessages(grantee);\n    case \"consume\":\n      return connector.grantConsumeMessages(grantee);\n    case \"full\":\n      return connector.grantFull(grantee);\n  }\n}\n\n/** Build an IAM connection result. */\nfunction buildIamResult(\n  connector: AnyConnector,\n  grant: Grant\n): ConnectionResult {\n  return { resource: connector, grant, connectionType: CONNECTION_TYPE.IAM };\n}\n\n/** Build a security group connection result. */\nfunction buildSecurityGroupResult(\n  resource: AnyConnector | IConnectable\n): ConnectionResult {\n  return { resource, connectionType: CONNECTION_TYPE.SECURITY_GROUP };\n}\n\n/** Validate and narrow access type for storage/dynamodb connectors. */\nfunction validateConnectionAccess(\n  access: ConnectionAccess | MessagingAccess | undefined,\n  connectorType: string,\n  defaultAccess: ConnectionAccess\n): ConnectionAccess {\n  if (access === undefined) return defaultAccess;\n  if (isConnectionAccess(access)) return access;\n  throw new Error(\n    `Invalid access \"${access}\" for ${connectorType} connector. ` +\n      `Valid values: read, write, readWrite`\n  );\n}\n\n/** Validate and narrow access type for queue connectors. */\nfunction validateMessagingAccess(\n  access: ConnectionAccess | MessagingAccess | undefined,\n  defaultAccess: MessagingAccess\n): MessagingAccess {\n  if (access === undefined) return defaultAccess;\n  if (isMessagingAccess(access)) return access;\n  throw new Error(\n    `Invalid access \"${access}\" for queue connector. ` +\n      `Valid values: send, consume, full`\n  );\n}\n\n/**\n * Require IConnectable for security group operations.\n * Throws a descriptive error if not provided.\n */\nfunction requireConnectable(\n  connectable: IConnectable | undefined,\n  context: string\n): asserts connectable is IConnectable {\n  if (!connectable) {\n    throw new Error(\n      `${context} requires an IConnectable to be provided. ` +\n        \"Ensure the compute resource (ECS, EC2, Lambda with VPC) implements IConnectable.\"\n    );\n  }\n}\n\n/**\n * Process connections from compute resources to data resources.\n *\n * Handles the unified connector interface, dispatching to:\n * - Security group rules for IConnectable and ISecurityGroupConnector resources\n * - IAM grants for IStorageConnector, IDynamoDBConnector, and IQueueConnector resources\n *\n * @param connections - Array of connection specifications\n * @param grantee - The IAM grantee (task role, execution role, etc.)\n * @param connectable - Optional IConnectable for security group rules\n * @returns Array of connection results\n *\n * @example\n * processConnections(\n *   [database, { resource: bucket, access: \"read\" }, queue],\n *   taskRole,\n *   service\n * );\n */\nexport function processConnections(\n  connections: ConnectionSpec[],\n  grantee: IGrantable,\n  connectable?: IConnectable\n): ConnectionResult[] {\n  return connections.map((spec) => {\n    const { resource, access } = isConnectionConfig(spec)\n      ? { resource: spec.resource, access: spec.access }\n      : { resource: spec, access: undefined };\n\n    // Handle unified connector interface (isConnector now returns AnyConnector)\n    if (isConnector(resource)) {\n      switch (resource.connectorType) {\n        case \"storage\": {\n          const validAccess = validateConnectionAccess(\n            access,\n            \"storage\",\n            DEFAULT_ACCESS.storage\n          );\n          return buildIamResult(\n            resource,\n            processStorageConnection(resource, grantee, validAccess)\n          );\n        }\n\n        case \"dynamodb\": {\n          const validAccess = validateConnectionAccess(\n            access,\n            \"dynamodb\",\n            DEFAULT_ACCESS.dynamodb\n          );\n          return buildIamResult(\n            resource,\n            processDynamoDBConnection(resource, grantee, validAccess)\n          );\n        }\n\n        case \"queue\": {\n          const validAccess = validateMessagingAccess(\n            access,\n            DEFAULT_ACCESS.queue\n          );\n          return buildIamResult(\n            resource,\n            processQueueConnection(resource, grantee, validAccess)\n          );\n        }\n\n        case \"securityGroup\":\n        case \"relational\": {\n          requireConnectable(\n            connectable,\n            `${resource.connectorType} connector`\n          );\n          connectable.connections.allowToDefaultPort(resource);\n          return buildSecurityGroupResult(resource);\n        }\n      }\n    }\n\n    // Legacy IConnectable path\n    if (isConnectable(resource)) {\n      requireConnectable(connectable, \"IConnectable resource\");\n      connectable.connections.allowToDefaultPort(resource);\n      return buildSecurityGroupResult(resource);\n    }\n\n    throw new Error(\n      \"Connection resource must be either an IConnector or IConnectable\"\n    );\n  });\n}\n"]}

package/dist/lib/patterns/aws/database.d.ts

@@ -1,7 +1,12 @@
 import { Construct } from "constructs";
 import type App from "../../app";
-import { type Secret } from "../../resources/aws/secrets";
+import { type DynamoDBKeySchema, type DynamoDBGlobalSecondaryIndex } from "../../resources/aws/database/dynamodb";
 import { type Connections, type IConnectable, type IVpc, type SubnetSelection } from "aws-cdk-lib/aws-ec2";
+import { type ITable } from "aws-cdk-lib/aws-dynamodb";
+import { type Secret } from "../../resources/aws/secrets";
+import { type IGrantable, type Grant } from "aws-cdk-lib/aws-iam";
+import { type IRelationalDatabase, type IDynamoDBDatabase, type RelationalDatabaseType } from "./interfaces/database.js";
+import { type IDynamoDBConnector, type ISecurityGroupConnector } from "./interfaces/connector.js";
 import { type IInstanceEngine, type IClusterEngine } from "aws-cdk-lib/aws-rds";
 import { Duration } from "aws-cdk-lib";
 import { type IKey } from "aws-cdk-lib/aws-kms";
@@ -132,6 +137,21 @@ export interface AuroraDatabaseProps extends BaseDatabaseProps {
     snapshotIdentifier?: string;
     /** Username from the snapshot (required when restoring from snapshot to reset password) */
     snapshotUsername?: string;
+    /** Allow access from VPC CIDR (avoids cross-stack cyclic dependencies with Lambda) */
+    allowVpcAccess?: boolean;
+    /**
+     * Make database publicly accessible from the internet.
+     * WARNING: This is a security risk and should only be used for development
+     * or when building Payload apps locally that need database access.
+     * When enabled, the database is placed in public subnets.
+     */
+    publiclyAccessible?: boolean;
+    /**
+     * IP address to allow access from when publiclyAccessible is true.
+     * If not specified, access is restricted to VPC only even when public.
+     * Format: CIDR notation (e.g., "203.0.113.0/32" for single IP)
+     */
+    allowedIpCidr?: string;
 }
 export interface GlobalAuroraDatabaseProps extends BaseDatabaseProps {
     type: "GlobalAurora";
@@ -178,19 +198,106 @@ export interface InstanceDatabaseProps extends BaseDatabaseProps {
     /** Username from the snapshot (required when restoring from snapshot to reset password) */
     snapshotUsername?: string;
 }
-export type IDatabaseProps = AuroraDatabaseProps | InstanceDatabaseProps | GlobalAuroraDatabaseProps;
+/**
+ * DynamoDB table configuration properties.
+ */
+export interface DynamoDBDatabaseProps {
+    type: "DynamoDB";
+    partitionKey: DynamoDBKeySchema;
+    sortKey?: DynamoDBKeySchema;
+    billingMode?: "PAY_PER_REQUEST" | "PROVISIONED";
+    readCapacity?: number;
+    writeCapacity?: number;
+    globalSecondaryIndexes?: DynamoDBGlobalSecondaryIndex[];
+    timeToLiveAttribute?: string;
+    stream?: "NEW_IMAGE" | "OLD_IMAGE" | "NEW_AND_OLD_IMAGES" | "KEYS_ONLY";
+    pointInTimeRecovery?: boolean;
+    encryption?: "AWS_OWNED" | "AWS_MANAGED" | "CUSTOMER_MANAGED";
+    removalPolicy?: "DESTROY" | "RETAIN" | "SNAPSHOT";
+}
+/**
+ * Relational database props union (Aurora, Instance, GlobalAurora).
+ */
+export type IRelationalDatabaseProps = AuroraDatabaseProps | InstanceDatabaseProps | GlobalAuroraDatabaseProps;
+/**
+ * All database props union.
+ */
+export type IDatabaseProps = AuroraDatabaseProps | InstanceDatabaseProps | GlobalAuroraDatabaseProps | DynamoDBDatabaseProps;
+/**
+ * Factory for creating type-safe database resources.
+ *
+ * @example
+ * // Aurora database - returns RelationalDatabase
+ * const aurora = app.addDatabase(DatabaseFactory.build("Main", {
+ *   type: "Aurora",
+ *   databaseName: "myapp"
+ * }));
+ * aurora.getHostEndpoint(); // Available
+ *
+ * @example
+ * // DynamoDB table - returns DynamoDBDatabase
+ * const cache = app.addDatabase(DatabaseFactory.build("Cache", {
+ *   type: "DynamoDB",
+ *   partitionKey: { name: "id", type: "S" }
+ * }));
+ * cache.getTableName(); // Available
+ * cache.grantReadWriteData(lambda); // Available
+ */
 export declare class DatabaseFactory {
-    static build<T extends IDatabaseProps>(id: string, props: T): (app: App, scope: Construct) => Database;
+    static build(id: string, props: AuroraDatabaseProps): (app: App, scope: Construct) => RelationalDatabase;
+    static build(id: string, props: InstanceDatabaseProps): (app: App, scope: Construct) => RelationalDatabase;
+    static build(id: string, props: GlobalAuroraDatabaseProps): (app: App, scope: Construct) => RelationalDatabase;
+    static build(id: string, props: DynamoDBDatabaseProps): (app: App, scope: Construct) => DynamoDBDatabase;
+}
+/**
+ * DynamoDB database wrapper implementing IDynamoDBDatabase interface.
+ * Provides type-safe access to DynamoDB table operations.
+ *
+ * @example
+ * const cache = app.addDatabase(DatabaseFactory.build("Cache", {
+ *   type: "DynamoDB",
+ *   partitionKey: { name: "id", type: "S" }
+ * }));
+ * cache.grantReadWriteData(lambda);
+ */
+export declare class DynamoDBDatabase extends Construct implements IDynamoDBDatabase, IDynamoDBConnector {
+    readonly databaseType: "DynamoDB";
+    readonly connectorType: "dynamodb";
+    readonly id: string;
+    private readonly table;
+    constructor(scope: Construct, id: string, props: DynamoDBDatabaseProps);
+    getTableName(): string;
+    getTableArn(): string;
+    getTable(): ITable;
+    getStreamArn(): string | undefined;
+    grantReadData(grantee: IGrantable): Grant;
+    grantWriteData(grantee: IGrantable): Grant;
+    grantReadWriteData(grantee: IGrantable): Grant;
+    grantFullAccess(grantee: IGrantable): Grant;
+    grantStreamRead(grantee: IGrantable): Grant;
 }
-export declare class Database extends Construct implements IConnectable {
-    id: string;
-    scope: Construct;
-    vpc: IVpc;
+/**
+ * Relational database wrapper implementing IRelationalDatabase interface.
+ * Supports Aurora, RDS Instance, and GlobalAurora database types.
+ *
+ * @example
+ * const db = app.addDatabase(DatabaseFactory.build("Main", {
+ *   type: "Aurora",
+ *   databaseName: "myapp"
+ * }));
+ * db.grantConnect(lambda);
+ */
+export declare class RelationalDatabase extends Construct implements IRelationalDatabase, ISecurityGroupConnector {
+    readonly id: string;
+    readonly scope: Construct;
+    readonly vpc: IVpc;
+    readonly databaseType: RelationalDatabaseType;
+    readonly connectorType: "relational";
     connections: Connections;
-    private databaseName;
+    private readonly _databaseName;
     private database;
-    constructor(scope: Construct, id: string, props: IDatabaseProps);
-    addDatabase(props: IDatabaseProps): void;
+    constructor(scope: Construct, id: string, props: IRelationalDatabaseProps);
+    addDatabase(props: IRelationalDatabaseProps): void;
     private addAurora;
     private addAuroraGlobal;
     private addRdsInstance;
@@ -199,5 +306,11 @@ export declare class Database extends Construct implements IConnectable {
     getHostEndpoint(): string;
     getHostPort(): string;
     getDatabaseName(): string;
+    /**
+     * Grant connect permissions to a grantee by adding it to the database security group.
+     * @param grantee The connectable principal to grant connect permissions to
+     */
+    grantConnect(grantee: IConnectable): void;
 }
-export {};
+export type { DynamoDBKeySchema, DynamoDBGlobalSecondaryIndex, DynamoDBTableProps } from "../../resources/aws/database/dynamodb";
+export { type IRelationalDatabase, type IDynamoDBDatabase, type AnyDatabase, type DatabaseType, type RelationalDatabaseType, isRelationalDatabase, isDynamoDBDatabase, isAuroraDatabase, isInstanceDatabase, isGlobalAuroraDatabase } from "./interfaces/database.js";