masonite-framework-orm 3.0.1__py3-none-any.whl

masoniteorm/commands/MakeMigrationCommand.py

@@ -0,0 +1,57 @@
+import datetime
+import os
+import pathlib
+
+from inflection import camelize, tableize
+
+from .Command import Command
+
+
+class MakeMigrationCommand(Command):
+    """
+    Creates a new migration file.
+
+    migration
+        {name : The name of the migration}
+        {--c|create=None : The table to create}
+        {--t|table=None : The table to alter}
+        {--d|directory=databases/migrations : The location of the migration directory}
+    """
+
+    def handle(self):
+        name = self.argument("name")
+        now = datetime.datetime.today()
+
+        if self.option("create") != "None":
+            table = self.option("create")
+            stub_file = "create_migration"
+        else:
+            table = self.option("table")
+            stub_file = "table_migration"
+
+        if table == "None":
+            table = tableize(name.replace("create_", "").replace("_table", ""))
+            stub_file = "create_migration"
+
+        migration_directory = self.option("directory")
+
+        with open(
+            os.path.join(
+                pathlib.Path(__file__).parent.absolute(),
+                f"stubs/{stub_file}.stub",
+            )
+        ) as fp:
+            output = fp.read()
+            output = output.replace("__MIGRATION_NAME__", camelize(name))
+            output = output.replace("__TABLE_NAME__", table)
+
+        file_name = f"{now.strftime('%Y_%m_%d_%H%M%S')}_{name}.py"
+
+        with open(
+            os.path.join(os.getcwd(), migration_directory, file_name), "w"
+        ) as fp:
+            fp.write(output)
+
+        self.info(
+            f"Migration file created: {os.path.join(migration_directory, file_name)}"
+        )

masoniteorm/commands/MakeModelCommand.py

@@ -0,0 +1,78 @@
+import os
+import pathlib
+
+from inflection import camelize, tableize, underscore
+
+from .Command import Command
+
+
+class MakeModelCommand(Command):
+    """
+    Creates a new model file.
+
+    model
+        {name : The name of the model}
+        {--m|migration : Optionally create a migration file}
+        {--s|seeder : Optionally create a seeder file}
+        {--c|create : If the migration file should create a table}
+        {--t|table : If the migration file should modify an existing table}
+        {--p|pep : Makes the file into pep 8 standards}
+        {--d|directory=app : The location of the model directory}
+        {--D|migrations-directory=databases/migrations : The location of the migration directory}
+        {--S|seeders-directory=databases/seeds : The location of the seeders directory}
+    """
+
+    def handle(self):
+        name = self.argument("name")
+
+        model_directory = self.option("directory")
+
+        with open(
+            os.path.join(
+                pathlib.Path(__file__).parent.absolute(), "stubs/model.stub"
+            )
+        ) as fp:
+            output = fp.read()
+            output = output.replace("__CLASS__", camelize(name))
+
+        if self.option("pep"):
+            file_name = f"{underscore(name)}.py"
+        else:
+            file_name = f"{camelize(name)}.py"
+
+        full_directory_path = os.path.join(os.getcwd(), model_directory)
+
+        if os.path.exists(os.path.join(full_directory_path, file_name)):
+            self.line(
+                f'<error>Model "{name}" Already Exists ({full_directory_path}/{file_name})</error>'
+            )
+            return
+
+        os.makedirs(
+            os.path.dirname(os.path.join(full_directory_path)), exist_ok=True
+        )
+
+        with open(
+            os.path.join(os.getcwd(), model_directory, file_name), "w+"
+        ) as fp:
+            fp.write(output)
+
+        self.info(f"Model created: {os.path.join(model_directory, file_name)}")
+        if self.option("migration"):
+            migrations_directory = self.option("migrations-directory")
+            if self.option("table"):
+                self.call(
+                    "migration",
+                    f"update_{tableize(name)}_table --table {tableize(name)} --directory {migrations_directory}",
+                )
+            else:
+                self.call(
+                    "migration",
+                    f"create_{tableize(name)}_table --create {tableize(name)} --directory {migrations_directory}",
+                )
+
+        if self.option("seeder"):
+            directory = self.option("seeders-directory")
+            self.call(
+                "seed", f"{self.argument('name')} --directory {directory}"
+            )

masoniteorm/commands/MakeModelDocstringCommand.py

@@ -0,0 +1,37 @@
+from ..config import load_config
+from .Command import Command
+
+
+class MakeModelDocstringCommand(Command):
+    """
+    Generate model docstring and type hints (for auto-completion).
+
+    model:docstring
+        {table : The table you want to generate docstring and type hints}
+        {--t|type-hints : The table you want to generate docstring and type hints}
+        {--c|connection=default : The connection you want to use}
+    """
+
+    def handle(self):
+        table = self.argument("table")
+        DB = load_config(self.option("config")).DB
+
+        schema = DB.get_schema_builder(self.option("connection"))
+
+        if not schema.has_table(table):
+            return self.line_error(
+                f"There is no such table {table} for this connection."
+            )
+
+        self.info(f"Model Docstring for table: {table}")
+        print('"""')
+        for _, column in schema.get_columns(table).items():
+            length = f"({column.length})" if column.length else ""
+            default = f" default: {column.default}"
+            print(f"{column.name}: {column.column_type}{length}{default}")
+        print('"""')
+
+        if self.option("type-hints"):
+            self.info(f"Model Type Hints for table: {table}")
+            for name, column in schema.get_columns(table).items():
+                print(f"    {name}:{column.column_python_type.__name__}")

masoniteorm/commands/MakeObserverCommand.py

@@ -0,0 +1,54 @@
+import os
+import pathlib
+
+from inflection import camelize, underscore
+
+from .Command import Command
+
+
+class MakeObserverCommand(Command):
+    """
+    Creates a new observer file.
+
+    observer
+        {name : The name of the observer}
+        {--m|model=None : The name of the model}
+        {--d|directory=app/observers : The location of the observers directory}
+    """
+
+    def handle(self):
+        name = self.argument("name")
+        model = self.option("model")
+        if model == "None":
+            model = name
+
+        observer_directory = self.option("directory")
+
+        with open(
+            os.path.join(
+                pathlib.Path(__file__).parent.absolute(), "stubs/observer.stub"
+            )
+        ) as fp:
+            output = fp.read()
+            output = output.replace("__CLASS__", camelize(name))
+            output = output.replace("__MODEL_VARIABLE__", underscore(model))
+            output = output.replace("__MODEL__", camelize(model))
+
+        file_name = f"{camelize(name)}Observer.py"
+
+        full_directory_path = os.path.join(os.getcwd(), observer_directory)
+
+        if os.path.exists(os.path.join(full_directory_path, file_name)):
+            self.line(
+                f'<error>Observer "{name}" Already Exists ({full_directory_path}/{file_name})</error>'
+            )
+            return
+
+        os.makedirs(os.path.join(full_directory_path), exist_ok=True)
+
+        with open(
+            os.path.join(os.getcwd(), observer_directory, file_name), "w+"
+        ) as fp:
+            fp.write(output)
+
+        self.info(f"Observer created: {file_name}")

masoniteorm/commands/MakeSeedCommand.py

@@ -0,0 +1,54 @@
+import os
+import pathlib
+
+from inflection import camelize, underscore
+
+from .Command import Command
+
+
+class MakeSeedCommand(Command):
+    """
+    Creates a new seed file.
+
+    seed
+        {name : The name of the seed}
+        {--d|directory=databases/seeds : The location of the seed directory}
+    """
+
+    def handle(self):
+        # get the contents of a stub file
+        # replace the placeholders of a stub file
+        # output the content to a file location
+        name = self.argument("name") + "TableSeeder"
+        seed_directory = self.option("directory")
+
+        file_name = underscore(name)
+        stub_file = "create_seed"
+
+        with open(
+            os.path.join(
+                pathlib.Path(__file__).parent.absolute(),
+                f"stubs/{stub_file}.stub",
+            )
+        ) as fp:
+            output = fp.read()
+            output = output.replace("__SEEDER_NAME__", camelize(name))
+
+        file_name = f"{underscore(name)}.py"
+        full_path = pathlib.Path(
+            os.path.join(os.getcwd(), seed_directory, file_name)
+        )
+
+        path_normalized = pathlib.Path(seed_directory) / pathlib.Path(
+            file_name
+        )
+
+        if os.path.exists(full_path):
+            return self.line(
+                f"<error>{path_normalized} already exists.</error>"
+            )
+
+        with open(full_path, "w") as fp:
+            fp.write(output)
+
+        self.info(f"Seed file created: {path_normalized}")

masoniteorm/commands/MigrateCommand.py

@@ -0,0 +1,46 @@
+import os
+
+from ..migrations import Migration
+from .Command import Command
+
+
+class MigrateCommand(Command):
+    """
+    Run migrations.
+
+    migrate
+        {--m|migration=all : Migration's name to be migrated}
+        {--c|connection=default : The connection you want to run migrations on}
+        {--f|force : Force migrations without prompt in production}
+        {--s|show : Shows the output of SQL for migrations that would be running}
+        {--schema=? : Sets the schema to be migrated}
+        {--d|directory=databases/migrations : The location of the migration directory}
+    """
+
+    def handle(self):
+        # prompt user for confirmation in production
+        if os.getenv("APP_ENV") == "production" and not self.option("force"):
+            answer = ""
+            while answer not in ["y", "n"]:
+                answer = input(
+                    "Do you want to run migrations in PRODUCTION ? (y/n)\n"
+                ).lower()
+            if answer != "y":
+                self.info("Migrations cancelled")
+                exit(0)
+        migration = Migration(
+            command_class=self,
+            connection=self.option("connection"),
+            migration_directory=self.option("directory"),
+            config_path=self.option("config"),
+            schema=self.option("schema"),
+        )
+        migration.create_table_if_not_exists()
+        if not migration.get_unran_migrations():
+            self.info("Nothing To Migrate!")
+            return
+
+        migration_name = self.option("migration")
+        show_output = self.option("show")
+
+        migration.migrate(migration=migration_name, output=show_output)

masoniteorm/commands/MigrateFreshCommand.py

@@ -0,0 +1,41 @@
+from ..migrations import Migration
+from .Command import Command
+
+
+class MigrateFreshCommand(Command):
+    """
+    Drops all tables and migrates them again.
+
+    migrate:fresh
+        {--c|connection=default : The connection you want to run migrations on}
+        {--d|directory=databases/migrations : The location of the migration directory}
+        {--f|ignore-fk=? : The connection you want to run migrations on}
+        {--s|seed=? : Seed database after fresh. The seeder to be ran can be provided in argument}
+        {--schema=? : Sets the schema to be migrated}
+        {--D|seed-directory=databases/seeds : The location of the seed directory if seed option is used.}
+    """
+
+    def handle(self):
+        migration = Migration(
+            command_class=self,
+            connection=self.option("connection"),
+            migration_directory=self.option("directory"),
+            config_path=self.option("config"),
+            schema=self.option("schema"),
+        )
+
+        migration.fresh(ignore_fk=self.option("ignore-fk"))
+
+        self.line("")
+
+        if self.option("seed") == "null":
+            self.call(
+                "seed:run",
+                f"None --directory {self.option('seed-directory')} --connection {self.option('connection')}",
+            )
+
+        elif self.option("seed"):
+            self.call(
+                "seed:run",
+                f"{self.option('seed')} --directory {self.option('seed-directory')} --connection {self.option('connection')}",
+            )

masoniteorm/commands/MigrateRefreshCommand.py

@@ -0,0 +1,41 @@
+from ..migrations import Migration
+from .Command import Command
+
+
+class MigrateRefreshCommand(Command):
+    """
+    Rolls back migrations and migrates them again.
+
+    migrate:refresh
+        {--m|migration=all : Migration's name to be refreshed}
+        {--c|connection=default : The connection you want to run migrations on}
+        {--d|directory=databases/migrations : The location of the migration directory}
+        {--s|seed=? : Seed database after refresh. The seeder to be ran can be provided in argument}
+        {--schema=? : Sets the schema to be migrated}
+        {--D|seed-directory=databases/seeds : The location of the seed directory if seed option is used.}
+    """
+
+    def handle(self):
+        migration = Migration(
+            command_class=self,
+            connection=self.option("connection"),
+            migration_directory=self.option("directory"),
+            config_path=self.option("config"),
+            schema=self.option("schema"),
+        )
+
+        migration.refresh(self.option("migration"))
+
+        self.line("")
+
+        if self.option("seed") == "null":
+            self.call(
+                "seed:run",
+                f"None --directory {self.option('seed-directory')} --connection {self.option('connection')}",
+            )
+
+        elif self.option("seed"):
+            self.call(
+                "seed:run",
+                f"{self.option('seed')} --directory {self.option('seed-directory')} --connection {self.option('connection')}",
+            )

masoniteorm/commands/MigrateResetCommand.py

@@ -0,0 +1,25 @@
+from ..migrations import Migration
+from .Command import Command
+
+
+class MigrateResetCommand(Command):
+    """
+    Reset migrations.
+
+    migrate:reset
+        {--m|migration=all : Migration's name to be rollback}
+        {--c|connection=default : The connection you want to run migrations on}
+        {--schema=? : Sets the schema to be migrated}
+        {--d|directory=databases/migrations : The location of the migration directory}
+    """
+
+    def handle(self):
+        migration = Migration(
+            command_class=self,
+            connection=self.option("connection"),
+            migration_directory=self.option("directory"),
+            config_path=self.option("config"),
+            schema=self.option("schema"),
+        )
+
+        migration.reset(self.option("migration"))

masoniteorm/commands/MigrateRollbackCommand.py

@@ -0,0 +1,26 @@
+from ..migrations import Migration
+from .Command import Command
+
+
+class MigrateRollbackCommand(Command):
+    """
+    Rolls back the last batch of migrations.
+
+    migrate:rollback
+        {--m|migration=all : Migration's name to be rollback}
+        {--c|connection=default : The connection you want to run migrations on}
+        {--s|show : Shows the output of SQL for migrations that would be running}
+        {--schema=? : Sets the schema to be migrated}
+        {--d|directory=databases/migrations : The location of the migration directory}
+    """
+
+    def handle(self):
+        Migration(
+            command_class=self,
+            connection=self.option("connection"),
+            migration_directory=self.option("directory"),
+            config_path=self.option("config"),
+            schema=self.option("schema"),
+        ).rollback(
+            migration=self.option("migration"), output=self.option("show")
+        )

masoniteorm/commands/MigrateStatusCommand.py

@@ -0,0 +1,51 @@
+from ..migrations import Migration
+from .Command import Command
+
+
+class MigrateStatusCommand(Command):
+    """
+    Display migrations status.
+
+    migrate:status
+        {--c|connection=default : The connection you want to run migrations on}
+        {--schema=? : Sets the schema to be migrated}
+        {--d|directory=databases/migrations : The location of the migration directory}
+    """
+
+    def handle(self):
+        migration = Migration(
+            command_class=self,
+            connection=self.option("connection"),
+            migration_directory=self.option("directory"),
+            config_path=self.option("config"),
+            schema=self.option("schema"),
+        )
+        migration.create_table_if_not_exists()
+        table = self.table()
+        table.set_header_row(["Ran?", "Migration", "Batch"])
+        migrations = []
+
+        for migration_data in migration.get_ran_migrations():
+            migration_file = migration_data["migration_file"]
+            batch = migration_data["batch"]
+
+            migrations.append(
+                [
+                    "<info>Y</info>",
+                    f"<comment>{migration_file}</comment>",
+                    f"<info>{batch}</info>",
+                ]
+            )
+
+        for migration_file in migration.get_unran_migrations():
+            migrations.append(
+                [
+                    "<error>N</error>",
+                    f"<comment>{migration_file}</comment>",
+                    "<info>-</info>",
+                ]
+            )
+
+        table.set_rows(migrations)
+
+        table.render(self.io)

masoniteorm/commands/SeedRunCommand.py

@@ -0,0 +1,35 @@
+from inflection import camelize, underscore
+
+from ..seeds import Seeder
+from .Command import Command
+
+
+class SeedRunCommand(Command):
+    """
+    Run seeds.
+
+    seed:run
+        {--c|connection=default : The connection you want to run migrations on}
+        {--dry : If the seed should run in dry mode}
+        {table=None : Name of the table to seed}
+        {--d|directory=databases/seeds : The location of the seed directory}
+    """
+
+    def handle(self):
+        seeder = Seeder(
+            dry=self.option("dry"),
+            seed_path=self.option("directory"),
+            connection=self.option("connection"),
+        )
+
+        if self.argument("table") == "None":
+            seeder.run_database_seed()
+            seeder_seeded = "Database Seeder"
+
+        else:
+            table = self.argument("table")
+            seeder_file = f"{underscore(table)}_table_seeder.{camelize(table)}TableSeeder"
+            seeder.run_specific_seed(seeder_file)
+            seeder_seeded = f"{camelize(table)}TableSeeder"
+
+        self.line(f"<info>{seeder_seeded} seeded!</info>")