@mstuercke/pulumi-modules 0.0.5 → 0.0.6

package/dist/auth0/Auth0.d.ts

@@ -0,0 +1,29 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type Auth0Domain = `${string}.auth0.com`;
+export type Auth0URL = `http://${string}` | `https://${string}`;
+export interface Auth0User {
+    name: string;
+    email: string;
+    password: string;
+    emailVerified: boolean;
+    appMetadata?: Record<string, unknown>;
+}
+export interface Auth0Args {
+    projectId: string;
+    environmentName: string;
+    tenantDisplayName: string;
+    clientDisplayName: string;
+    domain: Auth0Domain;
+    m2mClientId: string;
+    allowedUrls: Auth0URL[];
+    allowedLoginCallbackUrls?: Auth0URL[];
+    allowedLogoutCallbackUrls?: Auth0URL[];
+    nativeAppId?: `com.${string}`;
+    defaultUsers?: Auth0User[];
+    disableSignup?: boolean;
+}
+export declare class Auth0 extends Resource {
+    domain: string;
+    clientId: Output<string>;
+    constructor(id: string, args: Auth0Args, opts?: CustomResourceOptions);
+}

package/dist/auth0/index.d.ts

@@ -0,0 +1,5 @@
+import { Auth0 } from './Auth0';
+export * from './Auth0';
+export declare const auth0: {
+    Auth0: typeof Auth0;
+};

package/dist/domain/getDomain.d.ts

@@ -0,0 +1,13 @@
+import { type Provider } from '@pulumi/aws';
+export interface DataDomainOptions {
+    usEast1Provider: Provider;
+    name: `${string}.${string}`;
+}
+export type DomainResult = {
+    name: string;
+    zoneId: string;
+    nameServers: string[];
+    usEast1CertificateArn: string;
+    euCentral1CertificateArn: string;
+};
+export declare const getDomain: (options: DataDomainOptions) => Promise<DomainResult>;

package/dist/domain/index.d.ts

@@ -0,0 +1,4 @@
+export * from './getDomain';
+export declare const domain: {
+    getDomain: (options: import("./getDomain").DataDomainOptions) => Promise<import("./getDomain").DomainResult>;
+};

package/dist/iam/SimpleIamRolePolicy.d.ts

@@ -0,0 +1,6 @@
+import { iam } from '@pulumi/aws';
+import type { SimpleIamRolePolicyConfig } from './SimpleIamRolePolicyConfig.js';
+import { type CustomResourceOptions } from '@pulumi/pulumi';
+export declare class SimpleIamRolePolicy extends iam.RolePolicy {
+    constructor(iamRoleId: string, config: SimpleIamRolePolicyConfig, opts?: CustomResourceOptions);
+}

package/dist/iam/SimpleIamRolePolicyConfig.d.ts

@@ -0,0 +1,57 @@
+import type { Input } from '@pulumi/pulumi';
+import type { PolicyStatement } from '@pulumi/aws/iam';
+export type SimpleIamRolePolicyConfig = CustomPolicyConfig | DynamoDbPolicyConfig | TimestreamPolicyConfig | S3PolicyConfig | CognitoPolicyConfig | WebsocketPolicyConfig | ExecuteLambdaConfig | SnsPolicyConfig | EventBridgeConfig;
+interface CustomPolicyConfig {
+    type: 'custom';
+    name: string;
+    statements: PolicyStatement[];
+}
+interface DynamoDbPolicyConfig {
+    type: 'dynamodb';
+    level: 'full-access';
+    name: string;
+    tableArn: Input<string>;
+}
+interface TimestreamPolicyConfig {
+    type: 'timestream';
+    level: 'full-access';
+    name: string;
+    dbArn: Input<string>;
+    tableArn: Input<string>;
+}
+interface S3PolicyConfig {
+    type: 's3';
+    level: 'full-access';
+    name: string;
+    bucketArn: Input<string>;
+}
+interface CognitoPolicyConfig {
+    type: 'cognito';
+    level: 'full-access';
+    name: string;
+    userPoolArn: Input<string>;
+}
+interface WebsocketPolicyConfig {
+    type: 'websocket';
+    level: 'full-access';
+    name: string;
+    apiArn: '*';
+}
+interface SnsPolicyConfig {
+    type: 'sns';
+    level: 'publish-message';
+    name: string;
+    snsTopicArn: Input<string>;
+}
+interface ExecuteLambdaConfig {
+    type: 'execute-lambda';
+    name: string;
+    lambdaArn: Input<string>;
+}
+interface EventBridgeConfig {
+    type: 'event-bridge';
+    level: 'enable-disable-rule';
+    name: string;
+    ruleArn: Input<string>;
+}
+export {};

package/dist/iam/index.d.ts

@@ -0,0 +1,6 @@
+import { SimpleIamRolePolicy } from './SimpleIamRolePolicy';
+export * from './SimpleIamRolePolicy';
+export * from './SimpleIamRolePolicyConfig';
+export declare const iam: {
+    SimpleIamRolePolicy: typeof SimpleIamRolePolicy;
+};

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export * from './auth0';
+export * from './domain';
+export * from './iam';
+export * from './lambda';
+export * from './mongodb';
+export * from './rest';
+export * from './s3';
+export * from './website';
+export * from './websocket';
+export declare const mstuercke: {
+    auth0: {
+        Auth0: typeof import("./auth0").Auth0;
+    };
+    domain: {
+        getDomain: (options: import("./domain").DataDomainOptions) => Promise<import("./domain").DomainResult>;
+    };
+    iam: {
+        SimpleIamRolePolicy: typeof import("./iam").SimpleIamRolePolicy;
+    };
+    lambda: {
+        NodeLambdaFunction: typeof import("./lambda").NodeLambdaFunction;
+    };
+    mongodb: {
+        MongoDBCustomInstance: typeof import("./mongodb").MongoDBCustomInstance;
+        MongoDBDefaultInstance: typeof import("./mongodb").MongoDBDefaultInstance;
+        MongoDBUser: typeof import("./mongodb").MongoDBUser;
+    };
+    rest: {
+        RestApi: typeof import("./rest").RestApi;
+    };
+    s3: {
+        PublicS3Bucket: typeof import("./s3").PublicS3Bucket;
+    };
+    website: {
+        StaticWebsite: typeof import("./website").StaticWebsite;
+    };
+    websocket: {
+        WebsocketApi: typeof import("./websocket").WebsocketApi;
+    };
+};

package/dist/lambda/NodeLambdaFunction.d.ts

@@ -0,0 +1,20 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+import { type SimpleIamRolePolicyConfig } from '../iam';
+import type { WithInputs } from './WithInputs.js';
+export type NodeLambdaFunctionArgs<EnvironmentVariables> = {
+    name: string;
+    runtime?: string;
+    functionHandler?: string;
+    memorySize?: number;
+    timeoutSeconds?: number;
+    lambdaPath: string;
+    additionalIamRolePolicies?: SimpleIamRolePolicyConfig[];
+    environmentVariables?: WithInputs<EnvironmentVariables>;
+    projectId: string;
+};
+export declare class NodeLambdaFunction<EnvironmentVariables extends Record<string, string> = Record<string, string>> extends Resource {
+    name: string;
+    arn: Output<string>;
+    invokeArn: Output<string>;
+    constructor(args: NodeLambdaFunctionArgs<EnvironmentVariables>, opts?: CustomResourceOptions);
+}

package/dist/lambda/WithInputs.d.ts

@@ -0,0 +1,4 @@
+import type { Input } from '@pulumi/pulumi';
+export type WithInputs<T> = {
+    [key in keyof T]: Input<T[key]>;
+};

package/dist/lambda/index.d.ts

@@ -0,0 +1,5 @@
+import { NodeLambdaFunction } from './NodeLambdaFunction';
+export * from './NodeLambdaFunction';
+export declare const lambda: {
+    NodeLambdaFunction: typeof NodeLambdaFunction;
+};

package/dist/mongodb/MongoDB.d.ts

@@ -0,0 +1,13 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type MongoDBArgs = {
+    organizationId: string;
+    projectId: string;
+    environmentName: string;
+};
+export declare class MongoDB extends Resource {
+    readonly connectionString: Output<string>;
+    readonly databaseName: string;
+    readonly username: string;
+    readonly password: Output<string>;
+    constructor(args: MongoDBArgs, opts?: CustomResourceOptions);
+}

package/dist/mongodb/MongoDBCustomInstance.d.ts

@@ -0,0 +1,12 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type MongoDBCustomInstanceArgs = {
+    organizationId: string;
+    projectId: string;
+    environmentName: string;
+};
+export declare class MongoDBCustomInstance extends Resource {
+    readonly mongoProjectId: Output<string>;
+    readonly connectionString: Output<string>;
+    readonly databaseName: string;
+    constructor(args: MongoDBCustomInstanceArgs, opts?: CustomResourceOptions);
+}

package/dist/mongodb/MongoDBDefaultInstance.d.ts

@@ -0,0 +1,12 @@
+import { type CustomResourceOptions, type Output, Resource } from '@pulumi/pulumi';
+export type MongoDBDefaultInstanceArgs = {
+    organizationId: string;
+    projectId: string;
+    environmentName: string;
+};
+export declare class MongoDBDefaultInstance extends Resource {
+    readonly mongoProjectId: Output<string>;
+    readonly connectionString: Output<string>;
+    readonly databaseName: string;
+    constructor(args: MongoDBDefaultInstanceArgs, opts?: CustomResourceOptions);
+}

package/dist/mongodb/MongoDBUser.d.ts

@@ -0,0 +1,12 @@
+import { type CustomResourceOptions, type Input, type Output, Resource } from '@pulumi/pulumi';
+export type MongoDBUserArgs = {
+    mongoProjectId: Input<string>;
+    databaseName: string;
+    projectId: string;
+    environmentName: string;
+};
+export declare class MongoDBUser extends Resource {
+    readonly username: string;
+    readonly password: Output<string>;
+    constructor(args: MongoDBUserArgs, opts?: CustomResourceOptions);
+}

package/dist/mongodb/index.d.ts

@@ -0,0 +1,11 @@
+import { MongoDBCustomInstance } from './MongoDBCustomInstance';
+import { MongoDBDefaultInstance } from './MongoDBDefaultInstance';
+import { MongoDBUser } from './MongoDBUser';
+export * from './MongoDBCustomInstance';
+export * from './MongoDBDefaultInstance';
+export * from './MongoDBUser';
+export declare const mongodb: {
+    MongoDBCustomInstance: typeof MongoDBCustomInstance;
+    MongoDBDefaultInstance: typeof MongoDBDefaultInstance;
+    MongoDBUser: typeof MongoDBUser;
+};

package/dist/rest/RestApi.d.ts

@@ -0,0 +1,19 @@
+import * as aws from '@pulumi/aws';
+import type { CustomResourceOptions, Input } from '@pulumi/pulumi';
+import type { NodeLambdaFunction } from '../lambda';
+export interface RestApiArgs {
+    name: string;
+    projectId: string;
+    lambdaFunction: NodeLambdaFunction;
+    timeoutSeconds?: number;
+    stageName?: string;
+    domain: {
+        zoneId: Input<string>;
+        fullName: Input<string>;
+        usEast1CertificateArn: Input<string>;
+    };
+}
+export declare class RestApi extends aws.apigateway.RestApi {
+    readonly url: string;
+    constructor(id: string, args: RestApiArgs, opts?: CustomResourceOptions);
+}

package/dist/rest/index.d.ts

@@ -0,0 +1,5 @@
+import { RestApi } from './RestApi';
+export * from './RestApi';
+export declare const rest: {
+    RestApi: typeof RestApi;
+};

package/dist/s3/PublicS3Bucket.d.ts

@@ -0,0 +1,11 @@
+import { Bucket, type BucketArgs } from '@pulumi/aws/s3';
+import type { CustomResourceOptions } from '@pulumi/pulumi';
+type PublicS3BucketArgs = {
+    name: string;
+    allowPresignedPost?: boolean;
+    tags?: BucketArgs['tags'];
+};
+export declare class PublicS3Bucket extends Bucket {
+    constructor(id: string, args: PublicS3BucketArgs, opts?: CustomResourceOptions);
+}
+export {};

package/dist/s3/index.d.ts

@@ -0,0 +1,5 @@
+import { PublicS3Bucket } from './PublicS3Bucket';
+export * from './PublicS3Bucket';
+export declare const s3: {
+    PublicS3Bucket: typeof PublicS3Bucket;
+};

package/dist/website/StaticWebsite.d.ts

@@ -0,0 +1,17 @@
+import { type CustomResourceOptions, type Input, Resource } from '@pulumi/pulumi';
+import { type PublicS3Bucket } from '../s3';
+export interface StaticWebsiteArgs {
+    projectId: string;
+    environmentName: string;
+    filesPath: string;
+    customDomain?: {
+        fullName: Input<string>;
+        zoneId: Input<string>;
+        usEast1CertificateArn: Input<string>;
+    };
+}
+export declare class StaticWebsite extends Resource {
+    url: string;
+    bucket: PublicS3Bucket;
+    constructor(id: string, args: StaticWebsiteArgs, opts?: CustomResourceOptions);
+}

package/dist/website/index.d.ts

@@ -0,0 +1,5 @@
+import { StaticWebsite } from './StaticWebsite';
+export * from './StaticWebsite';
+export declare const website: {
+    StaticWebsite: typeof StaticWebsite;
+};

package/dist/website/readFilesRecursive.d.ts

@@ -0,0 +1,8 @@
+interface File {
+    absolutePath: string;
+    relativePath: string;
+    md5: string;
+    mimeType: string;
+}
+export declare function readFilesRecursive(dir: string): File[];
+export {};

package/dist/websocket/WebsocketApi.d.ts

@@ -0,0 +1,22 @@
+import { type CustomResourceOptions, type Input, type Output, Resource } from '@pulumi/pulumi';
+import type { NodeLambdaFunction } from '../lambda';
+export interface WebsocketApiArgs {
+    name: string;
+    lambdaFunction: NodeLambdaFunction;
+    routeThrottling?: {
+        rateLimit?: number;
+        burstLimit?: number;
+    };
+    stageName?: string;
+    domain: {
+        zoneId: Input<string>;
+        fullName: Input<string>;
+        euCentral1CertificateArn: Input<string>;
+    };
+    projectId: string;
+}
+export declare class WebsocketApi extends Resource {
+    id: Output<string>;
+    url: string;
+    constructor(id: string, args: WebsocketApiArgs, opts?: CustomResourceOptions);
+}

package/dist/websocket/index.d.ts

@@ -0,0 +1,5 @@
+import { WebsocketApi } from './WebsocketApi';
+export * from './WebsocketApi';
+export declare const websocket: {
+    WebsocketApi: typeof WebsocketApi;
+};

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@mstuercke/pulumi-modules",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "files": [
-    "src/**/!(*.test|*.fixture).ts",
-    "tsconfig.json",
+    "dist/**/!(*.test|*.fixture).ts",
     "README.md"
   ],
-  "exports": "./src/index.ts",
+  "exports": "./dist/index.js",
   "type": "module",
   "scripts": {
     "typeCheck": "tsc --noEmit",
+    "build": "tsc",
     "bump:major": "npm version major --git-tag-version false",
     "bump:minor": "npm version minor --git-tag-version false",
     "bump:patch": "npm version patch --git-tag-version false",

package/src/auth0/Auth0.ts

@@ -1,162 +0,0 @@
-import {type CustomResourceOptions, type Output, Resource} from '@pulumi/pulumi'
-import {Client, ClientCredentials, Connection, ConnectionClient, Provider, Tenant, User} from '@pulumi/auth0'
-
-export type Auth0Domain = `${string}.auth0.com`
-export type Auth0URL = `http://${string}` | `https://${string}`
-
-export interface Auth0User {
-  name: string
-  email: string
-  password: string
-  emailVerified: boolean
-  appMetadata?: Record<string, unknown>
-}
-
-export interface Auth0Args {
-  projectId: string
-  environmentName: string
-  tenantDisplayName: string
-  clientDisplayName: string
-  domain: Auth0Domain
-  m2mClientId: string
-  allowedUrls: Auth0URL[]
-  allowedLoginCallbackUrls?: Auth0URL[]
-  allowedLogoutCallbackUrls?: Auth0URL[]
-  nativeAppId?: `com.${string}`
-  defaultUsers?: Auth0User[]
-  disableSignup?: boolean
-}
-
-export class Auth0 extends Resource {
-  domain: string
-  clientId: Output<string>
-
-  constructor(id: string, args: Auth0Args, opts?: CustomResourceOptions) {
-    super('mstuercke:auth0:Auth0', id, false, undefined, opts)
-
-    const {
-      projectId,
-      environmentName,
-      tenantDisplayName,
-      clientDisplayName,
-      domain,
-      m2mClientId,
-      allowedUrls,
-      allowedLoginCallbackUrls,
-      allowedLogoutCallbackUrls,
-      nativeAppId,
-      defaultUsers = [],
-      disableSignup = false,
-    } = args
-
-    new Provider('provider', {}, {parent: this})
-
-    new Tenant(
-      'tenant',
-      {
-        friendlyName: tenantDisplayName,
-        flags: {
-          enableClientConnections: false,
-        },
-      },
-      {parent: this},
-    )
-
-    const nativeAppCallbackUrls = nativeAppId
-      ? [
-          `${nativeAppId}.auth0://${domain}/ios/${nativeAppId}/callback`,
-          `${nativeAppId}.auth0://${domain}/android/${nativeAppId}/callback`,
-        ]
-      : []
-    const client = new Client(
-      'client',
-      {
-        name: clientDisplayName,
-        appType: 'spa',
-        callbacks: [...(allowedLoginCallbackUrls || allowedUrls), ...nativeAppCallbackUrls],
-        webOrigins: allowedUrls,
-        allowedLogoutUrls: [...(allowedLogoutCallbackUrls || allowedUrls), ...nativeAppCallbackUrls],
-        jwtConfiguration: {
-          alg: 'RS256',
-        },
-        addons: {},
-      },
-      {parent: this},
-    )
-
-    const connection = new Connection(
-      'password-authentication',
-      {
-        name: `${projectId}-${environmentName}`,
-        strategy: 'auth0',
-        options: {
-          disableSignup: disableSignup,
-          bruteForceProtection: true,
-        },
-      },
-      {parent: this},
-    )
-
-    const m2mClientConnection = new ConnectionClient(
-      'password-authentication-m2m-client',
-      {
-        clientId: m2mClientId,
-        connectionId: connection.id,
-      },
-      {parent: client},
-    )
-
-    const clientConnection = new ConnectionClient(
-      'password-authentication-client',
-      {
-        clientId: client.id,
-        connectionId: connection.id,
-      },
-      {parent: client},
-    )
-
-    // TODO: Implement disabling of google-oauth2 (If possible, also disable "Username-Password-Authentication")
-    // // disable google-oauth2 on all clients
-    // const googleOauth2Connection = output(getConnection({name: 'google-oauth2'}))
-    // new ConnectionClients(
-    //   'google-oauth2-clients',
-    //   {
-    //     connectionId: googleOauth2Connection.id,
-    //     enabledClients: [],
-    //   },
-    //   {parent: client, dependsOn: [client]},
-    // )
-
-    new ClientCredentials(
-      'credentials',
-      {
-        clientId: client.id,
-        authenticationMethod: 'none',
-      },
-      {parent: this},
-    )
-
-    for (const defaultUser of defaultUsers) {
-      const {name, email, emailVerified, password, appMetadata} = defaultUser
-
-      new User(
-        `default-user-${defaultUser.email}`,
-        {
-          connectionName: connection.name,
-          name: name,
-          email: email,
-          emailVerified: emailVerified,
-          password: password,
-          appMetadata: appMetadata ? JSON.stringify(appMetadata) : undefined,
-        },
-        {
-          dependsOn: [m2mClientConnection, clientConnection],
-          parent: connection,
-        },
-      )
-    }
-
-    this.domain = domain
-    this.clientId = client.id
-  }
-}

package/src/auth0/index.ts

@@ -1,7 +0,0 @@
-import {Auth0} from './Auth0.ts'
-
-export * from './Auth0.ts'
-
-export const auth0 = {
-  Auth0,
-}

package/src/domain/getDomain.ts

@@ -1,32 +0,0 @@
-import {acm, type Provider, route53} from '@pulumi/aws'
-
-export interface DataDomainOptions {
-  usEast1Provider: Provider
-  name: `${string}.${string}`
-}
-
-export type DomainResult = {
-  name: string
-  zoneId: string
-  nameServers: string[]
-  usEast1CertificateArn: string
-  euCentral1CertificateArn: string
-}
-
-export const getDomain = async (options: DataDomainOptions): Promise<DomainResult> => {
-  const {usEast1Provider, name} = options
-
-  const zone = await route53.getZone({name})
-
-  const euCentral1Certificate = await acm.getCertificate({domain: name})
-
-  const usEast1Certificate = await acm.getCertificate({domain: name}, {provider: usEast1Provider})
-
-  return {
-    name: zone.name,
-    zoneId: zone.zoneId,
-    nameServers: zone.nameServers,
-    usEast1CertificateArn: usEast1Certificate.arn,
-    euCentral1CertificateArn: euCentral1Certificate.arn,
-  }
-}

package/src/domain/index.ts

@@ -1,7 +0,0 @@
-import {getDomain} from './getDomain.ts'
-
-export * from './getDomain.ts'
-
-export const domain = {
-  getDomain,
-}