I’m assuming that your goal is to add each of the files matched by *.json under src/dummyjsons to your archive.

That means that you’d need to have one source block for each of those files. Your first attempt failed because you instead declared one entire archive_file per source file: if that had worked, the many separate instances of archive_file.test would have all tried to write to the same output file, with each write containing only one of the source files.

You can ask Terraform to dynamically generate zero or more nested source blocks using a dynamic block:

data "archive_file" "test"{
  type        = "zip"
  output_path = "${path.module}/test.zip"

  source {
    content  = file("${path.module}/src/lambda/test.py")
    filename = "test.py"
  }

  # (...and all of the other hard-coded ones...)

  # Include all dummyjsons
  dynamic "source" {
    for_each = fileset("${path.module}/src/dummyjsons", "*.json")
    content {
      content  = file("${path.module}/src/dummyjsons/${source.value}")
      filename = "src/dummyjsons/${source.value}"
    }
  }
}

Notice that the for_each argument is now inside the dynamic block, and so the repetition is limited only to that block. dynamic blocks are slightly different to resource-level for_each in that Terraform literally generates multiple separate source blocks based on the given specification, so from the perspective of the hashicorp/archive provider (which is the one implementing this archive_file data source) this is indistinguishable from you having written out multiple source blocks directly.

Because the dynamic block has a smaller scope than for_each directly inside your data block, you refer to the value of the current element using source.value instead of each.value. The “source” identifier there is named after the block type.

I think your biggest problem is the generation of the archive.

Consider the following folder structure inside a Terraform module named terra03:

Assuming that you want to create an archive with all .py and .json files, with the exception of random.py and something.py you can create the archive like this:

locals {
  files_path = "${path.module}/src"

  # Filter by .py and .json extension
  files_to_include = fileset(local.files_path, "**/*.{json,py}")

  # Exclude random.py and something.py files
  files_to_exclude = fileset(local.files_path, "**/{random,something}.py")

  archive_files = setsubtract(local.files_to_include, local.files_to_exclude)
}

data "archive_file" "test" {
  type        = "zip"
  output_path = "test.zip"

  dynamic "source" {
    for_each = local.archive_files
    content {
      filename = source.value
      content  = file("${local.files_path}/${source.value}")
    }
  }
}

output "files_to_include" {
  value       = local.archive_files
  description = "Files to be included in the archive"
}

output "files_to_exclude" {
  value       = local.files_to_exclude
  description = "Files to be excluded from the archive"
}

Running terraform plan:

data.archive_file.test: Reading...
data.archive_file.test: Read complete after 0s [id=9a6c88d83866aeea36d380a28dc5a1b6a0270690]

Changes to Outputs:
  + files_to_exclude = [
      + "shared/random.py",
      + "shared/something.py",
    ]
  + files_to_include = [
      + "dummyjsons/dummy01.json",
      + "dummyjsons/dummy02.json",
      + "dummyjsons/dummy03.json",
      + "dummyjsons/dummy04.json",
      + "lambda/test.py",
      + "shared/constants.py",
      + "shared/exceptions.py",
      + "shared/utils.py",
    ]

For more details see fileset function and dynamic blocks