@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/util/Util_DynamoDb.res

@@ -0,0 +1,210 @@
+open PulumiAws.DynamoDb.Table
+@@warning("-44")
+open ReventlessInfra.Adapter
+
+let log = ReventlessCore.Logger.fromEnv()
+
+let toResourceInfo: table => Pulumi.Output.t<ReventlessInfra.Adapter.resourceInfo> = ({hashKey, rangeKey}) =>
+  (hashKey, rangeKey)
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((hashKey, rangeKey)) => ReventlessInfra.Adapter.StorageKeys({partitionKey: hashKey, sortKey: rangeKey}))
+
+let toResolvedTableOutput = ({name, id, arn, hashKey, rangeKey}) =>
+  (name, id, arn, hashKey, rangeKey)
+  ->Pulumi.Output.all5
+  ->Pulumi.Output.apply(((name, id, arn, hashKey, rangeKey)) => {
+    Util_DynamoDb_Runtime.id,
+    name,
+    arn,
+    hashKey,
+    rangeKey: ?(rangeKey->Option.map(rangeKey => rangeKey->Nullable.make)),
+  })
+
+let toResource = (~tags=?, {id, name, arn} as table) =>
+  make(
+    ~name,
+    ~id,
+    ~urn=arn,
+    ~service=name->Pulumi.Output.apply(_ => AWS.DynamoDb.service),
+    ~resourceInfo=table->toResourceInfo,
+    ~resourceType="aws:dynamodb:Table"->Pulumi.Output.make,
+    ~tags=?tags,
+  )
+
+
+let arn2tableName = arn =>
+  switch arn->String.split(":") {
+  | [_, _, _service, _region, _account, tableName] => tableName
+  | _ => JsError.throwWithMessage("Invalid ARN: " ++ arn)
+  }
+
+// Workaround when restore enabled: turn on ttl & pointInTimeRecovery again
+let enableTtl: string => promise<ttl> = async tableName => {
+  log.info(~comp="DynamoDb", `enableTimeToLive for ${tableName}`)
+
+  //open AwsSdk.DynamoDb_DynamoDb.UpdateTimeToLiveCommand
+  switch await {
+    tableName,
+    timeToLiveSpecification: {
+      enabled: true,
+      attributeName: Util_DynamoDb_Runtime.purgeTimeAttributeName,
+    },
+  }
+  ->AwsSdk.DynamoDb_DynamoDb.UpdateTimeToLiveCommand.make
+  ->AwsSdk.DynamoDb_DynamoDb.UpdateTimeToLiveCommand.send {
+  | res => {
+      enabled: res.timeToLiveSpecification.enabled,
+      attributeName: res.timeToLiveSpecification.attributeName,
+    }
+  }
+}
+
+let verifyTtl: (~expectedTtl: int=?, table) => Pulumi.Output.t<ttl> = (
+  ~expectedTtl=?,
+  {name, ttl},
+) =>
+  (name, ttl)
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.flatMap(((tableName, ttl)) => {
+    // Pulumi resolves table.ttl to undefined when no TTL is configured on the table.
+    // Cast to Nullable to safely handle this at the JS boundary.
+    let ttlOpt: option<ttl> = (ttl->Obj.magic: Nullable.t<ttl>)->Nullable.toOption
+    switch (ttlOpt->Option.flatMap(t => t.enabled), expectedTtl) {
+    | (None, Some(_))
+    | (Some(false), Some(_)) =>
+      enableTtl(tableName)
+    | _ => ttlOpt->Option.getOr({attributeName: ""})->Promise.resolve
+    }->Pulumi.Output.fromPromise
+  })
+
+let enablePointInTimeRecovery = async tableName => {
+  log.info(~comp="DynamoDb", `enablePointInTimeRecovery for ${tableName}`)
+
+  open AwsSdk.DynamoDb_DynamoDb
+
+  let updateContinuousBackups = UpdateContinuousBackupsCommand.make({
+    tableName,
+    pointInTimeRecoverySpecification: {pointInTimeRecoveryEnabled: true},
+  })
+  switch await updateContinuousBackups->UpdateContinuousBackupsCommand.send {
+  | res => {enabled: res.continuousBackupsDescription.continuousBackupsStatus == #ENABLED}
+  }
+}
+
+let verifyPointInTimeRecovery = (table: table) =>
+  (table.name, table.pointInTimeRecovery)
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.flatMap(((tableName, pointInTimeRecovery)) =>
+    switch pointInTimeRecovery.enabled {
+    | false => enablePointInTimeRecovery(tableName)
+    | true => pointInTimeRecovery->Promise.resolve
+    }->Pulumi.Output.fromPromise
+  )
+
+let updateTable: (~ttl: int=?, table) => table = (~ttl=?, table) => {
+  let newTtl = verifyTtl(~expectedTtl=?ttl, table)
+  let newPointInTimeRecovery = verifyPointInTimeRecovery(table)
+
+  {
+    ...table,
+    ttl: newTtl,
+    pointInTimeRecovery: newPointInTimeRecovery,
+  }
+}
+
+let makeTableArgs = (
+  ~attributes,
+  ~globalSecondaryIndexes=?,
+  ~ttl: option<int>=?,
+  ~rangeKey=?,
+  ~restoreSourceName=?,
+  ~tags=?,
+  ~streamEnabled=?,
+  ~streamViewType=?,
+) => {
+  let ttl = ttl->Option.map(_ =>
+    {
+      PulumiAws.DynamoDb.Table.enabled: true,
+      attributeName: Util_DynamoDb_Runtime.purgeTimeAttributeName,
+    }->Pulumi.Input.make
+  )
+
+  let restoreDateTime = ReventlessCore.Env.restoreDateTime
+
+  {
+    PulumiAws.DynamoDb.Table.attributes: attributes->Pulumi.Input.make,
+    hashKey: "id"->Pulumi.Input.make,
+    rangeKey: ?(rangeKey->Option.map(Pulumi.Input.make)),
+    billingMode: PAY_PER_REQUEST,
+    ?globalSecondaryIndexes,
+    ?tags,
+    ?ttl,
+    pointInTimeRecovery: {
+      enabled: true,
+    }->Pulumi.Input.make,
+    restoreSourceName: ?(restoreSourceName->Option.map(Pulumi.Input.make)),
+    restoreDateTime: ?(
+      restoreSourceName->Option.flatMap(_ => restoreDateTime->Option.map(Pulumi.Input.make))
+    ),
+    restoreToLatestTime: ?(
+      restoreSourceName->Option.map(_ => restoreDateTime->Option.isNone->Pulumi.Input.make)
+    ),
+    ?streamEnabled,
+    ?streamViewType,
+  }
+}
+
+let option2Str = opt =>
+  switch opt {
+  | Some(value) => `Some(${value})`
+  | None => "None"
+  }
+
+let makeTable = (
+  ~attributes,
+  ~globalSecondaryIndexes=?,
+  ~ttl: option<int>=?,
+  ~rangeKey=?,
+  ~tags=?,
+  ~opts,
+  name,
+) => {
+  let restoreSourceName =
+    Pulumi.Config.make(Some("restore"))
+    ->Pulumi.Config.getObject("tables")
+    ->Option.flatMap(tables => tables->Dict.get(name))
+
+  let (dependencies, registerResource) = Util_DynamoDb_TableManager.getDependencies()
+
+  let table = PulumiAws.DynamoDb.Table.make(
+    ~name,
+    ~args=makeTableArgs(
+      ~attributes,
+      ~globalSecondaryIndexes?,
+      ~ttl?,
+      ~rangeKey?,
+      ~restoreSourceName?,
+      ~tags?,
+    ),
+    ~opts={
+      ...opts,
+      dependsOn: dependencies->Pulumi.Output.asInput,
+    },
+  )
+
+  registerResource(table->Pulumi.Resource.makeFromJs)
+
+  restoreSourceName->Option.isNone
+  // Workaround when restore enabled
+    ? updateTable(~ttl?, table)
+    : table
+}
+
+let findResource = resources =>
+  resources->ReventlessCore.Util.Adapter.findResource(AWS.DynamoDb.service)
+
+let findResolvedResource = resources =>
+  resources->ReventlessCore.Util.Adapter.findResolvedResource(AWS.DynamoDb.service)
+
+let findResourceInOutput = resourcesOutput =>
+  resourcesOutput->ReventlessCore.Util.Adapter.findResourceInOutput(AWS.DynamoDb.service)

package/src/util/Util_DynamoDb.res.mjs

@@ -0,0 +1,218 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as AWS$ReventlessAws from "../adapter/AWS.res.mjs";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
+import * as Util_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Adapter.res.mjs";
+import * as Util_DynamoDb_Runtime$ReventlessAws from "./Util_DynamoDb_Runtime.res.mjs";
+import * as Util_DynamoDb_TableManager$ReventlessAws from "./Util_DynamoDb_TableManager.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function toResourceInfo(param) {
+  return Pulumi.all([
+    param.hashKey,
+    param.rangeKey
+  ]).apply(param => ({
+    TAG: "StorageKeys",
+    partitionKey: param[0],
+    sortKey: param[1]
+  }));
+}
+
+function toResolvedTableOutput(param) {
+  return Pulumi.all([
+    param.name,
+    param.id,
+    param.arn,
+    param.hashKey,
+    param.rangeKey
+  ]).apply(param => ({
+    id: param[1],
+    name: param[0],
+    arn: param[2],
+    hashKey: param[3],
+    rangeKey: Stdlib_Option.map(param[4], rangeKey => rangeKey)
+  }));
+}
+
+function toResource(tags, table) {
+  let name = table.name;
+  return Adapter$ReventlessInfra.make(name, table.id, table.arn, name.apply(param => AWS$ReventlessAws.DynamoDb.service), toResourceInfo(table), undefined, undefined, Pulumi.output("aws:dynamodb:Table"), undefined, tags);
+}
+
+function arn2tableName(arn) {
+  let match = arn.split(":");
+  if (match.length !== 6) {
+    return Stdlib_JsError.throwWithMessage("Invalid ARN: " + arn);
+  } else {
+    return match[5];
+  }
+}
+
+async function enableTtl(tableName) {
+  log.info("DynamoDb", undefined, `enableTimeToLive for ` + tableName);
+  let res = await DynamoDb_DynamoDb$AwsSdk.UpdateTimeToLiveCommand.send(new ClientDynamodb.UpdateTimeToLiveCommand({
+    TableName: tableName,
+    TimeToLiveSpecification: {
+      Enabled: true,
+      AttributeName: Util_DynamoDb_Runtime$ReventlessAws.purgeTimeAttributeName
+    }
+  }));
+  return {
+    attributeName: res.TimeToLiveSpecification.AttributeName,
+    enabled: res.TimeToLiveSpecification.Enabled
+  };
+}
+
+function verifyTtl(expectedTtl, param) {
+  return Output$Pulumi.flatMap(Pulumi.all([
+    param.name,
+    param.ttl
+  ]), param => {
+    let tableName = param[0];
+    let ttlOpt = Primitive_option.fromNullable(param[1]);
+    let match = Stdlib_Option.flatMap(ttlOpt, t => t.enabled);
+    if (match !== undefined) {
+      if (!match && expectedTtl !== undefined) {
+        return enableTtl(tableName);
+      }
+    } else if (expectedTtl !== undefined) {
+      return enableTtl(tableName);
+    }
+    return Promise.resolve(Stdlib_Option.getOr(ttlOpt, {
+      attributeName: ""
+    }));
+  });
+}
+
+async function enablePointInTimeRecovery(tableName) {
+  log.info("DynamoDb", undefined, `enablePointInTimeRecovery for ` + tableName);
+  let updateContinuousBackups = new ClientDynamodb.UpdateContinuousBackupsCommand({
+    TableName: tableName,
+    PointInTimeRecoverySpecification: {
+      PointInTimeRecoveryEnabled: true
+    }
+  });
+  let res = await DynamoDb_DynamoDb$AwsSdk.UpdateContinuousBackupsCommand.send(updateContinuousBackups);
+  return {
+    enabled: res.ContinuousBackupsDescription.ContinuousBackupsStatus === "ENABLED"
+  };
+}
+
+function verifyPointInTimeRecovery(table) {
+  return Output$Pulumi.flatMap(Pulumi.all([
+    table.name,
+    table.pointInTimeRecovery
+  ]), param => {
+    let pointInTimeRecovery = param[1];
+    if (pointInTimeRecovery.enabled) {
+      return Promise.resolve(pointInTimeRecovery);
+    } else {
+      return enablePointInTimeRecovery(param[0]);
+    }
+  });
+}
+
+function updateTable(ttl, table) {
+  let newTtl = verifyTtl(ttl, table);
+  let newPointInTimeRecovery = verifyPointInTimeRecovery(table);
+  return {
+    arn: table.arn,
+    name: table.name,
+    id: table.id,
+    hashKey: table.hashKey,
+    rangeKey: table.rangeKey,
+    streamEnabled: table.streamEnabled,
+    streamArn: table.streamArn,
+    streamLabel: table.streamLabel,
+    ttl: newTtl,
+    pointInTimeRecovery: newPointInTimeRecovery
+  };
+}
+
+function makeTableArgs(attributes, globalSecondaryIndexes, ttl, rangeKey, restoreSourceName, tags, streamEnabled, streamViewType) {
+  let ttl$1 = Stdlib_Option.map(ttl, param => ({
+    attributeName: Util_DynamoDb_Runtime$ReventlessAws.purgeTimeAttributeName,
+    enabled: true
+  }));
+  let restoreDateTime = process.env.RESTORE_DATE_TIME;
+  return {
+    attributes: attributes,
+    hashKey: "id",
+    billingMode: "PAY_PER_REQUEST",
+    rangeKey: Stdlib_Option.map(rangeKey, prim => prim),
+    globalSecondaryIndexes: globalSecondaryIndexes,
+    tags: tags,
+    streamEnabled: streamEnabled,
+    streamViewType: streamViewType,
+    ttl: ttl$1,
+    pointInTimeRecovery: {
+      enabled: true
+    },
+    restoreSourceName: Stdlib_Option.map(restoreSourceName, prim => prim),
+    restoreDateTime: Stdlib_Option.flatMap(restoreSourceName, param => Stdlib_Option.map(restoreDateTime, prim => prim)),
+    restoreToLatestTime: Stdlib_Option.map(restoreSourceName, param => Stdlib_Option.isNone(restoreDateTime))
+  };
+}
+
+function option2Str(opt) {
+  if (opt !== undefined) {
+    return `Some(` + opt + `)`;
+  } else {
+    return "None";
+  }
+}
+
+function makeTable(attributes, globalSecondaryIndexes, ttl, rangeKey, tags, opts, name) {
+  let restoreSourceName = Stdlib_Option.flatMap(new Pulumi.Config("restore").getObject("tables"), tables => tables[name]);
+  let match = Util_DynamoDb_TableManager$ReventlessAws.getDependencies();
+  let newrecord = {...opts};
+  let table = new (Aws.dynamodb.Table)(name, makeTableArgs(attributes, globalSecondaryIndexes, ttl, rangeKey, restoreSourceName, tags, undefined, undefined), (newrecord.dependsOn = match[0], newrecord));
+  match[1](table);
+  if (Stdlib_Option.isNone(restoreSourceName)) {
+    return updateTable(ttl, table);
+  } else {
+    return table;
+  }
+}
+
+function findResource(resources) {
+  return Util_Adapter$ReventlessCore.findResource(resources, AWS$ReventlessAws.DynamoDb.service);
+}
+
+function findResolvedResource(resources) {
+  return Util_Adapter$ReventlessCore.findResolvedResource(resources, AWS$ReventlessAws.DynamoDb.service);
+}
+
+function findResourceInOutput(resourcesOutput) {
+  return Util_Adapter$ReventlessCore.findResourceInOutput(resourcesOutput, AWS$ReventlessAws.DynamoDb.service);
+}
+
+export {
+  log,
+  toResourceInfo,
+  toResolvedTableOutput,
+  toResource,
+  arn2tableName,
+  enableTtl,
+  verifyTtl,
+  enablePointInTimeRecovery,
+  verifyPointInTimeRecovery,
+  updateTable,
+  makeTableArgs,
+  option2Str,
+  makeTable,
+  findResource,
+  findResolvedResource,
+  findResourceInOutput,
+}
+/* log Not a pure module */

package/src/util/Util_DynamoDbStream.res

@@ -0,0 +1,138 @@
+let toResourceInfo = (table: PulumiAws.DynamoDb.Table.t) =>
+  table.streamArn->Pulumi.Output.apply(streamArn => ReventlessInfra.Adapter.StreamSource({sourceUrn: streamArn}))
+
+let streamArnFromDynamoDbTableResource = (resource: ReventlessInfra.Adapter.resource) =>
+  resource.resourceInfo->Pulumi.Output.apply(resourceInfo =>
+    switch resourceInfo {
+    | StreamSource({sourceUrn}) => sourceUrn
+    | _ =>
+      let tableName = resource.name->Pulumi.Output.get
+      JsError.throwWithMessage("No streamArn field given for table " ++ tableName)
+    }
+  )
+
+let toResource = (~tags=?, table: PulumiAws.DynamoDb.Table.t): ReventlessInfra.Adapter.resource =>
+  ReventlessInfra.Adapter.make(
+    ~name=table.name,
+    ~id=table.id,
+    ~urn=table.arn,
+    ~service=table.name->Pulumi.Output.apply(_ => AWS.DynamoDbStream.service),
+    ~resourceInfo=table->toResourceInfo,
+    ~resourceType="aws:dynamodb:Table"->Pulumi.Output.make,
+    ~tags=?tags,
+  )
+
+let toStreamResource = (table: ReventlessInfra.Adapter.resource): ReventlessInfra.Adapter.resource => {
+  let streamArn = table->streamArnFromDynamoDbTableResource
+
+  ReventlessInfra.Adapter.make(
+    ~name=table.name,
+    ~id=streamArn,
+    ~urn=streamArn,
+    ~service=table.name->Pulumi.Output.apply(_ => AWS.DynamoDbStream.service),
+    ~resourceType="aws:dynamodb:Stream"->Pulumi.Output.make,
+  )
+}
+
+// Workaround when restore enabled: turn on stream, ttl & pointInTimeRecovery again
+open AwsSdk.DynamoDb_DynamoDb
+
+let log = ReventlessCore.Logger.fromEnv()
+
+let enableStream = async tableName => {
+  log.info(~comp="DynamoDbStream", `enableStream for ${tableName}`)
+
+  switch await UpdateTableCommand.make({
+    tableName,
+    streamSpecification: {
+      streamEnabled: true,
+      streamViewType: #NEW_IMAGE,
+    },
+  })->UpdateTableCommand.send {
+  | res => (
+      res.tableDescription.streamSpecification.streamEnabled,
+      Some(res.tableDescription.latestStreamArn),
+      res.tableDescription.latestStreamLabel,
+    )
+  }
+}
+
+let verifyStream = (table: PulumiAws.DynamoDb.Table.t) =>
+  (table.name, table.streamEnabled, table.streamArn, table.streamLabel)
+  ->Pulumi.Output.all4
+  ->Pulumi.Output.flatMap(((tableName, streamEnabled, streamArn, streamLabel)) =>
+    switch streamEnabled {
+    | None
+    | Some(false) =>
+      enableStream(tableName)
+    | Some(true) => (true, Some(streamArn), streamLabel)->Promise.resolve
+    }->Pulumi.Output.fromPromise
+  )
+
+let updateTable: (~ttl: int=?, PulumiAws.DynamoDb.Table.table) => PulumiAws.DynamoDb.Table.table = (
+  ~ttl=?,
+  table,
+) => {
+  let streamInfo = verifyStream(table)
+
+  let newTtl = Util_DynamoDb.verifyTtl(~expectedTtl=?ttl, table)
+  let newPointInTimeRecovery = Util_DynamoDb.verifyPointInTimeRecovery(table)
+
+  {
+    ...table,
+    streamEnabled: streamInfo->Pulumi.Output.apply(((enabled, _, _)) => Some(enabled)),
+    streamArn: streamInfo->Pulumi.Output.apply(((_, streamArn, _)) => streamArn->Option.getOr("")),
+    streamLabel: streamInfo->Pulumi.Output.apply(((_, _, streamLabel)) => streamLabel),
+    ttl: newTtl,
+    pointInTimeRecovery: newPointInTimeRecovery,
+  }
+}
+
+let makeTable = (
+  ~attributes,
+  ~globalSecondaryIndexes=?,
+  ~ttl: option<int>=?,
+  ~rangeKey=?,
+  ~streamViewType,
+  ~tags=?,
+  ~opts,
+  name,
+) => {
+  let restoreSourceName =
+    Pulumi.Config.make(Some("restore"))
+    ->Pulumi.Config.getObject("tables")
+    ->Option.flatMap(tables => tables->Dict.get(name))
+
+  let (dependencies, registerResource) = Util_DynamoDb_TableManager.getDependencies()
+
+  let table = PulumiAws.DynamoDb.Table.make(
+    ~name,
+    ~args=Util_DynamoDb.makeTableArgs(
+      ~attributes,
+      ~globalSecondaryIndexes?,
+      ~ttl?,
+      ~rangeKey?,
+      ~restoreSourceName?,
+      ~streamEnabled=true,
+      ~streamViewType,
+      ~tags?,
+    ),
+    ~opts={
+      ...opts,
+      dependsOn: dependencies->Pulumi.Output.asInput,
+    },
+  )
+
+  registerResource(table->Pulumi.Resource.makeFromJs)
+
+  restoreSourceName->Option.isNone
+  // Workaround when restore enabled
+    ? updateTable(~ttl?, table)
+    : table
+}
+
+let findResource = resources =>
+  resources->ReventlessCore.Util.Adapter.findResource(AWS.DynamoDbStream.service)
+
+let findResolvedResource = resources =>
+  resources->ReventlessCore.Util.Adapter.findResolvedResource(AWS.DynamoDbStream.service)

package/src/util/Util_DynamoDbStream.res.mjs

@@ -0,0 +1,134 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as AWS$ReventlessAws from "../adapter/AWS.res.mjs";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
+import * as Util_Adapter$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Adapter.res.mjs";
+import * as Util_DynamoDb$ReventlessAws from "./Util_DynamoDb.res.mjs";
+import * as Util_DynamoDb_TableManager$ReventlessAws from "./Util_DynamoDb_TableManager.res.mjs";
+
+function toResourceInfo(table) {
+  return table.streamArn.apply(streamArn => ({
+    TAG: "StreamSource",
+    sourceUrn: streamArn
+  }));
+}
+
+function streamArnFromDynamoDbTableResource(resource) {
+  return resource.resourceInfo.apply(resourceInfo => {
+    if (typeof resourceInfo === "object" && resourceInfo.TAG === "StreamSource") {
+      return resourceInfo.sourceUrn;
+    }
+    let tableName = resource.name.get();
+    return Stdlib_JsError.throwWithMessage("No streamArn field given for table " + tableName);
+  });
+}
+
+function toResource(tags, table) {
+  return Adapter$ReventlessInfra.make(table.name, table.id, table.arn, table.name.apply(param => AWS$ReventlessAws.DynamoDbStream.service), toResourceInfo(table), undefined, undefined, Pulumi.output("aws:dynamodb:Table"), undefined, tags);
+}
+
+function toStreamResource(table) {
+  let streamArn = streamArnFromDynamoDbTableResource(table);
+  return Adapter$ReventlessInfra.make(table.name, streamArn, streamArn, table.name.apply(param => AWS$ReventlessAws.DynamoDbStream.service), undefined, undefined, undefined, Pulumi.output("aws:dynamodb:Stream"), undefined, undefined);
+}
+
+let log = Logger$ReventlessCore.fromEnv();
+
+async function enableStream(tableName) {
+  log.info("DynamoDbStream", undefined, `enableStream for ` + tableName);
+  let res = await DynamoDb_DynamoDb$AwsSdk.UpdateTableCommand.send(new ClientDynamodb.UpdateTableCommand({
+    TableName: tableName,
+    StreamSpecification: {
+      StreamEnabled: true,
+      StreamViewType: "NEW_IMAGE"
+    }
+  }));
+  return [
+    res.TableDescription.StreamSpecification.StreamEnabled,
+    res.TableDescription.LatestStreamArn,
+    res.TableDescription.LatestStreamLabel
+  ];
+}
+
+function verifyStream(table) {
+  return Output$Pulumi.flatMap(Pulumi.all([
+    table.name,
+    table.streamEnabled,
+    table.streamArn,
+    table.streamLabel
+  ]), param => {
+    let streamEnabled = param[1];
+    let tableName = param[0];
+    if (streamEnabled !== undefined && streamEnabled) {
+      return Promise.resolve([
+        true,
+        param[2],
+        param[3]
+      ]);
+    } else {
+      return enableStream(tableName);
+    }
+  });
+}
+
+function updateTable(ttl, table) {
+  let streamInfo = verifyStream(table);
+  let newTtl = Util_DynamoDb$ReventlessAws.verifyTtl(ttl, table);
+  let newPointInTimeRecovery = Util_DynamoDb$ReventlessAws.verifyPointInTimeRecovery(table);
+  return {
+    arn: table.arn,
+    name: table.name,
+    id: table.id,
+    hashKey: table.hashKey,
+    rangeKey: table.rangeKey,
+    streamEnabled: streamInfo.apply(param => param[0]),
+    streamArn: streamInfo.apply(param => Stdlib_Option.getOr(param[1], "")),
+    streamLabel: streamInfo.apply(param => param[2]),
+    ttl: newTtl,
+    pointInTimeRecovery: newPointInTimeRecovery
+  };
+}
+
+function makeTable(attributes, globalSecondaryIndexes, ttl, rangeKey, streamViewType, tags, opts, name) {
+  let restoreSourceName = Stdlib_Option.flatMap(new Pulumi.Config("restore").getObject("tables"), tables => tables[name]);
+  let match = Util_DynamoDb_TableManager$ReventlessAws.getDependencies();
+  let newrecord = {...opts};
+  let table = new (Aws.dynamodb.Table)(name, Util_DynamoDb$ReventlessAws.makeTableArgs(attributes, globalSecondaryIndexes, ttl, rangeKey, restoreSourceName, tags, true, streamViewType), (newrecord.dependsOn = match[0], newrecord));
+  match[1](table);
+  if (Stdlib_Option.isNone(restoreSourceName)) {
+    return updateTable(ttl, table);
+  } else {
+    return table;
+  }
+}
+
+function findResource(resources) {
+  return Util_Adapter$ReventlessCore.findResource(resources, AWS$ReventlessAws.DynamoDbStream.service);
+}
+
+function findResolvedResource(resources) {
+  return Util_Adapter$ReventlessCore.findResolvedResource(resources, AWS$ReventlessAws.DynamoDbStream.service);
+}
+
+export {
+  toResourceInfo,
+  streamArnFromDynamoDbTableResource,
+  toResource,
+  toStreamResource,
+  log,
+  enableStream,
+  verifyStream,
+  updateTable,
+  makeTable,
+  findResource,
+  findResolvedResource,
+}
+/* log Not a pure module */