polyn-cli 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc201c551bb6f0b5e55c32ff47557164de1a2020cd11e1997c2e2acc8f61025d
-  data.tar.gz: 50e911060818ec5b06db12ad09f683212b1b02fdb3241cafde48e8eccde2d4ad
+  metadata.gz: ddc537a719c0f6247ba0b2b160cf1571d475384e8f00a96cccd8c03ae61d80ae
+  data.tar.gz: 91f7c4694751bf1778f477135c9819f42dfe437ceb63f2ffa7b66f43d5b1c358
 SHA512:
-  metadata.gz: cc1541bbaa72a2126c6d42a0c40352e0baf347a2cf6855213d70361b77154516cf998365ed0ddf5734292427a8411ec7fc3085b44856db3f13d8716e9278da58
-  data.tar.gz: c46bf95e3fe9afa651fccab77d8bd9e9cf4671a02a9c5a05952ce6c3bc0ab8854a38839aeb71a1fda6c5c121875d43a759037d781a4f8d58367bfd84fea96359
+  metadata.gz: 5aeaef41c88a5e415579242acad2e23b986f8bbb3a22d1068ba089e3886d82abd5709217ed11165e17dbf44f1f4203f085c4923d7aa180e1f5c64031df7a8dc6
+  data.tar.gz: 04f1dd0f81e107ec17f07aff19d30981e1ffd0edbef32d1fd0ae573040f823e03d5fdefc7eb534276d5bf010e449d6d62c3144cc1c5b900939b6fa084c4efbd4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyn-cli (0.1.8)
+    polyn-cli (0.2.0)
       dotenv (~> 2.7.6)
       json_schemer (~> 0.2)
       nats-pure (~> 2.0.0)

data/README.md

@@ -10,9 +10,9 @@ gem install 'polyn-cli'
 
 ## Usage
 
-### Create New Events Codebase
+### Create New Schemas Codebase
 
-Run `polyn init` inside a directory to create a new `events` respository for managing your event schemas and NATS server configuration
+Run `polyn init` inside a directory to create a new `schemas` respository for managing your message schemas and NATS server configuration
 
 ### Stream Generator
 
@@ -20,11 +20,11 @@ Run `polyn gen:stream <stream_name>` to generate a new configuration file for a
 
 ### Schema Generator
 
-Run `polyn gen:schema <event_type>` to generate a new JSON Schema for an event
+Run `polyn gen:schema <schema_name>` to generate a new JSON Schema for a message
 
 ### Consumer Generator
 
-Run `polyn gen:consumer <stream_name> <destination_name> <event_type>` to generate new configuration for a consumer of a stream. It will be included in the same file as the stream configuration.
+Run `polyn gen:consumer <stream_name> <destination_name> <schema_name>` to generate new configuration for a consumer of a stream. It will be included in the same file as the stream configuration.
 
 ### Updating NATS Configuration and Schemas
 

data/lib/polyn/cli/consumer_generator.rb

@@ -9,10 +9,10 @@ module Polyn
 
       desc "Generates a new NATS Consumer configuration for a stream"
 
-      argument :stream_name, required: true, desc: "The name of the stream to consume events from"
+      argument :stream_name, required: true, desc: "The name of the stream to consume messages from"
       argument :destination_name, required: true,
-        desc: "The name of the application, service, or component consuming the event"
-      argument :event_type, required: true, desc: "The type of event being consumed"
+        desc: "The name of the application, service, or component consuming the message"
+      argument :message_name, required: true, desc: "The name of the message being consumed"
       class_option :dir, default: Dir.getwd
 
       source_root File.join(File.expand_path(__dir__), "../templates")
@@ -20,22 +20,22 @@ module Polyn
       def check_names
         Polyn::Cli::Naming.validate_stream_name!(stream_name)
         Polyn::Cli::Naming.validate_destination_name!(destination_name)
-        Polyn::Cli::Naming.validate_event_type!(event_type)
+        Polyn::Cli::Naming.validate_message_name!(message_name)
       end
 
       def check_stream_existance
-        unless File.exist?(file_path)
-          raise Polyn::Cli::Error,
-            "You must first create a stream configuration with "\
-            "`polyn gen:stream #{format_stream_name}`"
-        end
+        return if File.exist?(file_path)
+
+        raise Polyn::Cli::Error,
+          "You must first create a stream configuration with "\
+          "`polyn gen:stream #{format_stream_name}`"
       end
 
-      def check_event_type_schema
-        unless File.exist?(File.join(options.dir, "events", "#{event_type}.json"))
-          raise Polyn::Cli::Error,
-            "You must first create a schema with `polyn gen:schema #{event_type}`"
-        end
+      def check_schema
+        return if File.exist?(File.join(options.dir, "schemas", "#{message_name}.json"))
+
+        raise Polyn::Cli::Error,
+          "You must first create a schema with `polyn gen:schema #{message_name}`"
       end
 
       def format_stream_name
@@ -45,8 +45,8 @@ module Polyn
       def consumer_name
         dest = Polyn::Cli::Naming.colon_to_underscore(destination_name)
         dest = Polyn::Cli::Naming.dot_to_underscore(dest)
-        type = Polyn::Cli::Naming.dot_to_underscore(event_type)
-        "#{dest}_#{type}"
+        name = Polyn::Cli::Naming.dot_to_underscore(message_name)
+        "#{dest}_#{name}"
       end
 
       def file_name
@@ -65,7 +65,7 @@ module Polyn
             stream_id = jetstream_stream.#{stream_name}.id
             durable_name = "#{consumer_name}"
             deliver_all = true
-            filter_subject = "#{event_type}"
+            filter_subject = "#{message_name}"
             sample_freq = 100
           }
         TF

data/lib/polyn/cli/naming.rb

@@ -10,10 +10,10 @@ module Polyn
       end
 
       def self.validate_stream_name!(name)
-        unless name.match(/^[a-zA-Z0-9_]+$/)
-          raise Polyn::Cli::Error,
-            "Stream name must be all alphanumeric, uppercase, and underscore separated. Got #{name}"
-        end
+        return if name.match(/^[a-zA-Z0-9_]+$/)
+
+        raise Polyn::Cli::Error,
+          "Stream name must be all alphanumeric, uppercase, and underscore separated. Got #{name}"
       end
 
       def self.format_stream_name(name)
@@ -21,17 +21,17 @@ module Polyn
       end
 
       def self.validate_destination_name!(name)
-        unless name.is_a?(String) && name.match?(/\A[a-z0-9]+(?:(?:\.|:)[a-z0-9]+)*\z/)
-          raise Polyn::Cli::Error,
-            "Event destination must be lowercase, alphanumeric and dot/colon separated, got #{name}"
-        end
+        return if name.is_a?(String) && name.match?(/\A[a-z0-9]+(?:(?:\.|:)[a-z0-9]+)*\z/)
+
+        raise Polyn::Cli::Error,
+          "Message destination must be lowercase, alphanumeric and dot/colon separated, got #{name}"
       end
 
-      def self.validate_event_type!(name)
-        unless name.is_a?(String) && name.match?(/\A[a-z0-9]+(?:\.[a-z0-9]+)*\z/)
-          raise Polyn::Cli::Error,
-            "Event types must be lowercase, alphanumeric and dot separated"
-        end
+      def self.validate_message_name!(name)
+        return if name.is_a?(String) && name.match?(/\A[a-z0-9]+(?:\.[a-z0-9]+)*\z/)
+
+        raise Polyn::Cli::Error,
+          "Message names must be lowercase, alphanumeric and dot separated"
       end
 
       def self.dot_to_underscore(name)

data/lib/polyn/cli/schema_generator.rb

@@ -3,43 +3,43 @@
 module Polyn
   class Cli
     ##
-    # Generates a new JSON Schema file for an event
+    # Generates a new JSON Schema file for a message
     class SchemaGenerator < Thor::Group
       include Thor::Actions
 
-      desc "Generates a new JSON Schema file for an event"
+      desc "Generates a new JSON Schema file for a message"
 
-      argument :event_type, required: true
+      argument :message_name, required: true
       class_option :dir, default: Dir.getwd
 
       source_root File.join(File.expand_path(__dir__), "../templates")
 
-      def type
-        @type ||= event_type.split("/").last
+      def name
+        @name ||= message_name.split("/").last
       end
 
       def subdir
         @subdir ||= begin
-          split = event_type.split("/") - [type]
+          split = message_name.split("/") - [name]
           split.join("/")
         end
       end
 
       def check_name
-        Polyn::Cli::Naming.validate_event_type!(type)
+        Polyn::Cli::Naming.validate_message_name!(name)
       end
 
       def file_name
-        @file_name ||= File.join(subdir, "#{type}.json")
+        @file_name ||= File.join(subdir, "#{name}.json")
       end
 
       def schema_id
-        Polyn::Cli::Naming.dot_to_colon(type)
+        Polyn::Cli::Naming.dot_to_colon(name)
       end
 
       def create
         say "Creating new schema for #{file_name}"
-        template "generators/schema.json", File.join(options.dir, "events/#{file_name}")
+        template "generators/schema.json", File.join(options.dir, "schemas/#{file_name}")
       end
     end
   end

data/lib/polyn/cli/schema_loader.rb

@@ -3,17 +3,17 @@
 module Polyn
   class Cli
     ##
-    # Loads the JSON schmea into the event registry.
+    # Loads the JSON schema into the schema registry.
     class SchemaLoader
       include Thor::Actions
 
       STORE_NAME = "POLYN_SCHEMAS"
 
       ##
-      # Loads the events from the event repository into the Polyn event registry.
+      # Loads the schemas from the schema repository into the Polyn schema registry.
       # @return [Bool]
       def self.load(cli)
-        new(cli).load_events
+        new(cli).load_schemas
       end
 
       def initialize(thor, **opts)
@@ -22,21 +22,21 @@ module Polyn
         @store_name         = opts.fetch(:store_name, STORE_NAME)
         @bucket             = client.key_value(@store_name)
         @cloud_event_schema = Polyn::Cli::CloudEvent.to_h.freeze
-        @events_dir         = opts.fetch(:events_dir, File.join(Dir.pwd, "events"))
-        @events             = {}
-        @existing_events    = {}
+        @schemas_dir        = opts.fetch(:schemas_dir, File.join(Dir.pwd, "schemas"))
+        @schemas            = {}
+        @existing_schemas   = {}
       end
 
-      def load_events
-        thor.say "Loading events into the Polyn event registry from '#{events_dir}'"
-        read_events
-        load_existing_events
+      def load_schemas
+        thor.say "Loading schemas into the Polyn schema registry from '#{schemas_dir}'"
+        read_schemas
+        load_existing_schemas
 
-        events.each do |name, event|
-          bucket.put(name, JSON.generate(event))
+        schemas.each do |name, schema|
+          bucket.put(name, JSON.generate(schema))
         end
 
-        delete_missing_events
+        delete_missing_schemas
 
         true
       end
@@ -44,13 +44,13 @@ module Polyn
       private
 
       attr_reader :thor,
-        :events,
+        :schemas,
         :client,
         :bucket,
         :cloud_event_schema,
-        :events_dir,
+        :schemas_dir,
         :store_name,
-        :existing_events
+        :existing_schemas
 
       def connect
         opts = {
@@ -60,74 +60,74 @@ module Polyn
         }
 
         if Polyn::Cli.configuration.nats_tls
-          opts.tls = { context: ::OpenSSL::SSL::SSLContext.new(:TLSv1_2) }
+          opts[:tls] = { context: ::OpenSSL::SSL::SSLContext.new(:TLSv1_2) }
         end
 
         NATS.connect(opts).jetstream
       end
 
-      def read_events
-        event_files = Dir.glob(File.join(events_dir, "/**/*.json"))
-        validate_unique_event_types!(event_files)
+      def read_schemas
+        schema_files = Dir.glob(File.join(schemas_dir, "/**/*.json"))
+        validate_unique_schema_names!(schema_files)
 
-        event_files.each do |event_file|
-          thor.say "Loading 'event #{event_file}'"
-          data_schema = JSON.parse(File.read(event_file))
-          event_type  = File.basename(event_file, ".json")
-          validate_schema!(event_type, data_schema)
-          Polyn::Cli::Naming.validate_event_type!(event_type)
+        schema_files.each do |schema_file|
+          thor.say "Loading 'schema #{schema_file}'"
+          data_schema = JSON.parse(File.read(schema_file))
+          schema_name = File.basename(schema_file, ".json")
+          validate_schema!(schema_name, data_schema)
+          Polyn::Cli::Naming.validate_message_name!(schema_name)
           schema      = compose_cloud_event(data_schema)
 
-          events[event_type] = schema
+          schemas[schema_name] = schema
         end
       end
 
-      def validate_unique_event_types!(event_files)
-        duplicates = find_duplicates(event_files)
+      def validate_unique_schema_names!(schema_files)
+        duplicates = find_duplicates(schema_files)
         return if duplicates.empty?
 
-        messages = duplicates.reduce([]) do |memo, (event_type, files)|
-          memo << [event_type, *files].join("\n")
+        messages = duplicates.reduce([]) do |memo, (schema_name, files)|
+          memo << [schema_name, *files].join("\n")
         end
         message  = [
-          "There can only be one of each event type. The following events were duplicated:",
+          "There can only be one of each schema name. The following schemas were duplicated:",
           *messages,
         ].join("\n")
         raise Polyn::Cli::ValidationError, message
       end
 
-      def find_duplicates(event_files)
-        event_types = event_files.group_by do |event_file|
-          File.basename(event_file, ".json")
+      def find_duplicates(schema_files)
+        schema_names = schema_files.group_by do |schema_file|
+          File.basename(schema_file, ".json")
         end
-        event_types.each_with_object({}) do |(event_type, files), hash|
-          hash[event_type] = files if files.length > 1
+        schema_names.each_with_object({}) do |(schema_name, files), hash|
+          hash[schema_name] = files if files.length > 1
           hash
         end
       end
 
-      def validate_schema!(event_type, schema)
+      def validate_schema!(schema_name, schema)
         JSONSchemer.schema(schema)
       rescue StandardError => e
         raise Polyn::Cli::ValidationError,
-          "Invalid JSON Schema document for event #{event_type}\n#{e.message}\n"\
+          "Invalid JSON Schema document for event #{schema_name}\n#{e.message}\n"\
           "#{JSON.pretty_generate(schema)}"
       end
 
-      def compose_cloud_event(event_schema)
+      def compose_cloud_event(data_schema)
         cloud_event_schema.merge({
           "definitions" => cloud_event_schema["definitions"].merge({
-            "datadef" => event_schema,
+            "datadef" => data_schema,
           }),
         })
       end
 
-      def load_existing_events
+      def load_existing_schemas
         sub = client.subscribe("#{key_prefix}.>")
 
         loop do
-          msg                                                     = sub.next_msg
-          existing_events[msg.subject.gsub("#{key_prefix}.", "")] = msg.data unless msg.data.empty?
+          msg                                                      = sub.next_msg
+          existing_schemas[msg.subject.gsub("#{key_prefix}.", "")] = msg.data unless msg.data.empty?
         # A timeout is the only mechanism given to indicate there are no
         # more messages
         rescue NATS::IO::Timeout
@@ -140,11 +140,11 @@ module Polyn
         "$KV.#{store_name}"
       end
 
-      def delete_missing_events
-        missing_events = existing_events.keys - events.keys
-        missing_events.each do |event|
-          thor.say "Deleting event #{event}"
-          bucket.delete(event)
+      def delete_missing_schemas
+        missing_schemas = existing_schemas.keys - schemas.keys
+        missing_schemas.each do |schema|
+          thor.say "Deleting schema #{schema}"
+          bucket.delete(schema)
         end
       end
     end

data/lib/polyn/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Polyn
   class Cli
-    VERSION = "0.1.8"
+    VERSION = "0.2.0"
   end
 end

data/lib/polyn/cli.rb

@@ -48,11 +48,11 @@ module Polyn
       end
 
       method_option :dir, default: Dir.getwd
-      desc "init", "initializes a Polyn event repository"
+      desc "init", "initializes a Polyn schema repository"
       def init
-        say "Initializing Polyn event repository"
+        say "Initializing Polyn schema repository"
         directory "tf", File.join(options.dir, "tf")
-        directory "events", File.join(options.dir, "events")
+        directory "schemas", File.join(options.dir, "schemas")
         template "docker-compose.yml", File.join(options.dir, "docker-compose.yml")
         template "Dockerfile", File.join(options.dir, "Dockerfile")
         template ".dockerignore", File.join(options.dir, ".dockerignore")
@@ -91,7 +91,7 @@ module Polyn
         end
       end
 
-      desc "up", "updates the JetStream streams and consumers, as well the Polyn event registry"
+      desc "up", "updates the JetStream streams and consumers, as well the Polyn schema registry"
       def up
         terraform_root = File.join(Dir.getwd, "tf")
         # We only want to run nats in the docker container if
@@ -110,8 +110,8 @@ module Polyn
           end
         end
 
-        say "Updating Polyn event registry"
-        Polyn::Cli::SchemaLoader.new(self).load_events
+        say "Updating Polyn schema registry"
+        Polyn::Cli::SchemaLoader.new(self).load_schemas
       end
 
       private
@@ -158,12 +158,12 @@ module Polyn
         remove_file File.join(tf_root, "backend.tf")
       end
 
-      register(Polyn::Cli::SchemaGenerator, "gen:schema", "gen:schema EVENT_TYPE",
-        "Generates a new JSON Schema file for an event")
-      register(Polyn::Cli::StreamGenerator, "gen:stream", "gen:stream NAME",
+      register(Polyn::Cli::SchemaGenerator, "gen:schema", "gen:schema SCHEMA_NAME",
+        "Generates a new JSON Schema file for an schema")
+      register(Polyn::Cli::StreamGenerator, "gen:stream", "gen:stream SCHEMA_NAME",
         "Generates a new stream configuration with boilerplate")
       register(Polyn::Cli::ConsumerGenerator, "gen:consumer",
-        "gen:consumer STREAM_NAME DESTINATION_NAME EVENT_TYPE",
+        "gen:consumer STREAM_NAME DESTINATION_NAME SCHEMA_NAME",
         "Generates a new NATS Consumer configuration with boilerplate")
     end
   end

data/lib/polyn/templates/Dockerfile

@@ -5,8 +5,8 @@ RUN gem install bundler
 RUN bundle install
 
 FROM base as app
-WORKDIR /events
-ADD events ./events
+WORKDIR /schemas
+ADD schemas ./schemas
 ADD tf ./tf
 
 FROM app as dev

data/lib/polyn/templates/README.md

@@ -1,6 +1,6 @@
-# Polyn Events Repository
+# Polyn Schemas Repository
 
-This repository contains all of the events and terraform resources for the Polyn services
+This repository contains all of the schemas and terraform resources for the Polyn services
 environment.
 
 1. Install [Ruby](https://github.com/asdf-vm/asdf-ruby)
@@ -11,7 +11,7 @@ environment.
 5. Ensure Docker & Docker Compose is installed
 6. Call `bundle exec polyn tf_init` if this is the first time using terraform in the codebase.
 7. Call `bundle exec polyn up`. By default this will run in `development` mode, which will start the NATS
-   server, configure it via Terraform, and update the Polyn Event Registry.
+   server, configure it via Terraform, and update the Polyn Schema Registry.
 
 ### Running NATS locally
 
@@ -29,40 +29,35 @@ Each stream should have its own configuration file under `./tf`. Run `bundle exe
 
 Run `bundle exec polyn gen:consumer <stream_name> <destination_name> <event_type>` to generate new configuration for a consumer of a stream. It will be included in the same file as the stream configuration.
 
-## Event Schemas
+## Message Schemas
 
-Run `bundle exec polyn gen:schema <event_type>` to generate a new JSON Schema for an event
+Run `bundle exec polyn gen:schema <schema_name>` to generate a new JSON Schema for a message
 
-All the schemas for your events should live in the `./events` directory.
-The name of your schema file should be the same as your event, but with `.json` at the end.
-So if you have an event called `widgets.created.v1` you would create a schema file called `widgets.created.v1.json` in the `./events` directory.
+All the schemas for your messages should live in the `./schemas` directory.
+The name of your schema file should be the same as your message, but with `.json` at the end.
+So if you have an message called `widgets.created.v1` you would create a schema file called `widgets.created.v1.json` in the `./schemas` directory.
 Every schema should be a valid [JSON Schema](https://json-schema.org/) document.
-The Polyn CLI tool will combine your event schema with the [Cloud Events Schema](https://cloudevents.io/) when it adds it to the Polyn Event Registry.
+The Polyn CLI tool will combine your message schema with the [Cloud Events Schema](https://cloudevents.io/) when it adds it to the Polyn Schema Registry.
 This means you only need to include the JSON Schema for the `data` portion of the Cloud Event and not the entire Cloud Event schema.
 
 ### Subdirectories
 
-If you'd like to organize your events by team ownership or some other convention, you can use subdirectories to do so. The full event type should still be part of the file name. You should also ensure there are not duplicate event types in different directories as only one schema can be defined per event type.
+If you'd like to organize your messages by team ownership or some other convention, you can use subdirectories to do so. The full message name should still be part of the file name. You should also ensure there are not duplicate schema names in different directories as only one schema can be defined per message name.
 
 You can generate a schema in a subdirectory like this: `bundle exec polyn gen:schema some/nested/dir/widgets.created.v1`
 
 ## Schema Versioning
 
-### New Event
+### New Message
 
-A new event schema file should be a lower-case, dot-separated, name with a `v1` suffix
+A new message schema file should be a lower-case, dot-separated, name with a `v1` suffix
 
-### Existing Event
+### Existing Message
 
-Existing event schemas can be changed without updating the file name if the change is backwards-compatible.
-Backwards-compatibile meaning that any services Producing or Consuming the event will not break or be invalid when the
-Polyn Event Registry is updated with the change. There are many ways to make breaking change and so you should be
-careful when you do this.
+Existing message schemas can be changed without updating the file name if the change is backwards-compatible.
+Backwards-compatibile meaning that any services Producing or Consuming the message will not break or be invalid when the Polyn Schema Registry is updated with the change. There are many ways to make breaking change and so you should be careful when you do this.
 
-Making a change to an event schema that is not backwards-compatible will require you to create a brand new
-json file. The new file should have the same name as your old file, but with the version number increased. Your
-Producers will need to continue producing both events until you are sure there are no more consumers using the
-old event.
+Making a change to a message schema that is not backwards-compatible will require you to create a brand new json file. The new file should have the same name as your old file, but with the version number increased. Your Producers will need to continue producing both message versions until you are sure there are no more consumers using the old message.
 
 ## Terraform State
 
@@ -74,7 +69,7 @@ For local development Polyn expects the `terraform.tfstate` file to exist in the
 
 ### Production
 
-In production Terraform recommends keeping `terraform.tfstate` in a [remote storage location](https://www.terraform.io/language/state). The remote state file should be the "source of truth" for your infrastucture and shouldn't be getting accessed during development. Depending on the size of your organization and security policies, not all developers will have access to the remote storage source and you don't want that to prohibit them from adding events, streams, or consumers.
+In production Terraform recommends keeping `terraform.tfstate` in a [remote storage location](https://www.terraform.io/language/state). The remote state file should be the "source of truth" for your infrastucture and shouldn't be getting accessed during development. Depending on the size of your organization and security policies, not all developers will have access to the remote storage source and you don't want that to prohibit them from adding schemas, streams, or consumers.
 
 Polyn expects you to keep a `./remote_state_config/backend.tf` file that configures a Terraform [backend](https://www.terraform.io/language/settings/backends/configuration). This will only be used when `POLYN_ENV=production`.
 

data/lib/polyn/templates/generators/schema.json

@@ -1,7 +1,7 @@
 {
   "$id": "<%= schema_id %>",
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "description": "This is why this event exists and what it does",
+  "description": "This is why this message exists and what it does",
   "type": "object",
   "properties": {
 

data/lib/polyn/templates/schemas/money.amount.v1.json

@@ -0,0 +1,15 @@
+{
+  "$id": "money:amount:v1",
+  "type": "object",
+  "properties": {
+    "currency": {
+      "type": "string",
+      "description": "currency code for the amount"
+    },
+    "amount": {
+      "type": "number",
+      "description": "amount of money"
+    }
+  },
+  "required": ["currency", "amount"]
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polyn-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - Jarod
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-21 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -106,10 +106,10 @@ files:
 - lib/polyn/templates/Gemfile
 - lib/polyn/templates/README.md
 - lib/polyn/templates/docker-compose.yml
-- lib/polyn/templates/events/.gitkeep
-- lib/polyn/templates/events/widgets.created.v1.json
 - lib/polyn/templates/generators/schema.json
 - lib/polyn/templates/generators/stream.tf
+- lib/polyn/templates/schemas/money.amount.v1.json
+- lib/polyn/templates/schemas/widgets.created.v1.json
 - lib/polyn/templates/tf/kv_buckets.tf
 - lib/polyn/templates/tf/provider.tf
 - lib/polyn/templates/tf/remote_state_config/backend.tf