From 738966c1af1c9f88707d99659f17657ecd079897 Mon Sep 17 00:00:00 2001 From: Zerohertz Date: Thu, 13 Feb 2025 22:29:33 +0900 Subject: [PATCH 1/4] :bento: init: alembic (related: #21) --- alembic.ini | 119 +++++++++++++++++++++++++++++++++++++++++ alembic/README | 1 + alembic/env.py | 78 +++++++++++++++++++++++++++ alembic/script.py.mako | 26 +++++++++ docs/alembic.md | 12 +++++ 5 files changed, 236 insertions(+) create mode 100644 alembic.ini create mode 100644 alembic/README create mode 100644 alembic/env.py create mode 100644 alembic/script.py.mako create mode 100644 docs/alembic.md diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..3700390 --- /dev/null +++ b/alembic.ini @@ -0,0 +1,119 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +# Use forward slashes (/) also on windows to provide an os agnostic path +script_location = alembic + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library. +# Any required deps can installed by adding `alembic[tz]` to the pip requirements +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to alembic/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +# version_path_separator = newline +# +# Use os.pathsep. Default configuration used for new projects. +version_path_separator = os + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +sqlalchemy.url = driver://user:pass@localhost/dbname + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the exec runner, execute a binary +# hooks = ruff +# ruff.type = exec +# ruff.executable = %(here)s/.venv/bin/ruff +# ruff.options = --fix REVISION_SCRIPT_FILENAME + +# Logging configuration +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/alembic/README b/alembic/README new file mode 100644 index 0000000..98e4f9c --- /dev/null +++ b/alembic/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 0000000..36112a3 --- /dev/null +++ b/alembic/env.py @@ -0,0 +1,78 @@ +from logging.config import fileConfig + +from sqlalchemy import engine_from_config +from sqlalchemy import pool + +from alembic import context + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +target_metadata = None + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline() -> None: + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + connectable = engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + with connectable.connect() as connection: + context.configure( + connection=connection, target_metadata=target_metadata + ) + + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 0000000..fbc4b07 --- /dev/null +++ b/alembic/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/docs/alembic.md b/docs/alembic.md new file mode 100644 index 0000000..b4a4a17 --- /dev/null +++ b/docs/alembic.md @@ -0,0 +1,12 @@ +```shell +$ source .venv/bin/activate +$ alembic init alembic + Creating directory '/home/zerohertz/workspace/alembic' ... done + Creating directory '/home/zerohertz/workspace/alembic/versions' ... done + Generating /home/zerohertz/workspace/alembic/env.py ... done + Generating /home/zerohertz/workspace/alembic.ini ... done + Generating /home/zerohertz/workspace/alembic/script.py.mako ... done + Generating /home/zerohertz/workspace/alembic/README ... done + Please edit configuration/connection/logging settings in + '/home/zerohertz/workspace/alembic.ini' before proceeding. +``` From 13fbc845ee47edc680275b7cf0798d532c8f71ec Mon Sep 17 00:00:00 2001 From: Zerohertz Date: Thu, 13 Feb 2025 22:36:36 +0900 Subject: [PATCH 2/4] :hammer: update: alembic setup (related: #21) --- alembic/env.py | 6 +++++- docs/alembic.md | 14 ++++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/alembic/env.py b/alembic/env.py index 36112a3..20debdc 100644 --- a/alembic/env.py +++ b/alembic/env.py @@ -1,3 +1,6 @@ +from app.core.configs import configs +from app.models.base import BaseModel + from logging.config import fileConfig from sqlalchemy import engine_from_config @@ -13,12 +16,13 @@ # This line sets up loggers basically. if config.config_file_name is not None: fileConfig(config.config_file_name) +config.set_main_option("sqlalchemy.url", configs.DATABASE_URI) # add your model's MetaData object here # for 'autogenerate' support # from myapp import mymodel # target_metadata = mymodel.Base.metadata -target_metadata = None +target_metadata = BaseModel.metadata # other values from the config, defined by the needs of env.py, # can be acquired: diff --git a/docs/alembic.md b/docs/alembic.md index b4a4a17..868a077 100644 --- a/docs/alembic.md +++ b/docs/alembic.md @@ -1,3 +1,5 @@ +## Init + ```shell $ source .venv/bin/activate $ alembic init alembic @@ -10,3 +12,15 @@ $ alembic init alembic Please edit configuration/connection/logging settings in '/home/zerohertz/workspace/alembic.ini' before proceeding. ``` + +## Setup + + + +```shell +$ sed -i '1i\from app.core.configs import configs\nfrom app.models.base import BaseModel\n' alembic/env.py +$ sed -i 's|target_metadata = None|target_metadata = BaseModel.metadata|g' alembic/env.py +$ sed -i '19i\config.set_main_option("sqlalchemy.url", configs.DATABASE_URI)' alembic/env.py +``` + + From eb33142fd9c26d8fea9cf9ce3184db9b17f3ccb6 Mon Sep 17 00:00:00 2001 From: Zerohertz Date: Thu, 13 Feb 2025 22:38:02 +0900 Subject: [PATCH 3/4] :art: style: alembic --- alembic/env.py | 12 ++++-------- docs/alembic.md | 1 + 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/alembic/env.py b/alembic/env.py index 20debdc..b6895b3 100644 --- a/alembic/env.py +++ b/alembic/env.py @@ -1,12 +1,10 @@ -from app.core.configs import configs -from app.models.base import BaseModel - from logging.config import fileConfig -from sqlalchemy import engine_from_config -from sqlalchemy import pool +from sqlalchemy import engine_from_config, pool from alembic import context +from app.core.configs import configs +from app.models.base import BaseModel # this is the Alembic Config object, which provides # access to the values within the .ini file in use. @@ -68,9 +66,7 @@ def run_migrations_online() -> None: ) with connectable.connect() as connection: - context.configure( - connection=connection, target_metadata=target_metadata - ) + context.configure(connection=connection, target_metadata=target_metadata) with context.begin_transaction(): context.run_migrations() diff --git a/docs/alembic.md b/docs/alembic.md index 868a077..1d53a98 100644 --- a/docs/alembic.md +++ b/docs/alembic.md @@ -21,6 +21,7 @@ $ alembic init alembic $ sed -i '1i\from app.core.configs import configs\nfrom app.models.base import BaseModel\n' alembic/env.py $ sed -i 's|target_metadata = None|target_metadata = BaseModel.metadata|g' alembic/env.py $ sed -i '19i\config.set_main_option("sqlalchemy.url", configs.DATABASE_URI)' alembic/env.py +$ isort alembic && black alembic ``` From d69bf2454932256fc5e2ed0988be5f58e3692eb6 Mon Sep 17 00:00:00 2001 From: Zerohertz Date: Fri, 14 Feb 2025 01:16:37 +0900 Subject: [PATCH 4/4] :sparkles: feat: db migration based on alembic (resolves: #21) --- Makefile | 18 +++ alembic/env.py | 19 ++- alembic/versions/0bdf3abd5213_init_alembic.py | 55 +++++++ app/core/configs.py | 2 +- docs/alembic.md | 141 ++++++++++++++++++ envs/test.env | 2 - k8s/postgresql/configmap.yaml | 2 - k8s/postgresql/fastapi.yaml | 2 + 8 files changed, 234 insertions(+), 7 deletions(-) create mode 100644 alembic/versions/0bdf3abd5213_init_alembic.py diff --git a/Makefile b/Makefile index 12172e3..8909578 100644 --- a/Makefile +++ b/Makefile @@ -12,6 +12,21 @@ lint: uv run isort app --check-only uv run black app --check +.PHONY: alembic +alembic: + @uv sync + @export DESCRIPTION=$$(cat README.md) && \ + set -o allexport && \ + source envs/$${ENV,,}.env && \ + set +o allexport && \ + if [ "$(revision)" = "downgrade" ]; then \ + uv run alembic downgrade base; \ + elif [ -z "$(revision)" ]; then \ + uv run alembic upgrade head; \ + else \ + uv run alembic revision --autogenerate -m "$(revision)"; \ + fi + .PHONY: test test: uv sync --group test @@ -59,6 +74,9 @@ swagger: .PHONY: deploy deploy: +ifndef tag + $(error tag is not set.) +endif echo $(tag) sed -i 's|zerohertzkr/fastapi-cookbook:[^ ]*|zerohertzkr/fastapi-cookbook:$(tag)|' k8s/postgresql/fastapi.yaml git add k8s/postgresql/fastapi.yaml diff --git a/alembic/env.py b/alembic/env.py index b6895b3..09e6ce5 100644 --- a/alembic/env.py +++ b/alembic/env.py @@ -1,9 +1,11 @@ +import asyncio from logging.config import fileConfig from sqlalchemy import engine_from_config, pool from alembic import context from app.core.configs import configs +from app.core.database import database from app.models.base import BaseModel # this is the Alembic Config object, which provides @@ -52,7 +54,7 @@ def run_migrations_offline() -> None: context.run_migrations() -def run_migrations_online() -> None: +def run_migrations_online_sync() -> None: """Run migrations in 'online' mode. In this scenario we need to create an Engine @@ -72,7 +74,20 @@ def run_migrations_online() -> None: context.run_migrations() +async def run_migrations_online_async() -> None: + connectable = database.engine + + def run_migrations(connection): + context.configure(connection=connection, target_metadata=target_metadata) + with context.begin_transaction(): + context.run_migrations() + + async with connectable.connect() as connection: + await connection.run_sync(run_migrations) + await connectable.dispose() + + if context.is_offline_mode(): run_migrations_offline() else: - run_migrations_online() + asyncio.run(run_migrations_online_async()) diff --git a/alembic/versions/0bdf3abd5213_init_alembic.py b/alembic/versions/0bdf3abd5213_init_alembic.py new file mode 100644 index 0000000..a465b1d --- /dev/null +++ b/alembic/versions/0bdf3abd5213_init_alembic.py @@ -0,0 +1,55 @@ +"""init: alembic + +Revision ID: 0bdf3abd5213 +Revises: +Create Date: 2025-02-14 01:13:13.993395 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = '0bdf3abd5213' +down_revision: Union[str, None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('user', + sa.Column('name', sa.String(length=255), nullable=False), + sa.Column('email', sa.String(length=255), nullable=False), + sa.Column('role', sa.Enum('ADMIN', 'USER', name='role'), nullable=False), + sa.Column('refresh_token', sa.String(length=255), nullable=True), + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.Column('updated_at', sa.DateTime(timezone=True), nullable=False), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('email'), + sa.UniqueConstraint('name') + ) + op.create_table('oauth', + sa.Column('user_id', sa.Integer(), nullable=False), + sa.Column('provider', sa.Enum('PASSWORD', 'GITHUB', 'GOOGLE', name='oauthprovider'), nullable=False), + sa.Column('password', sa.String(length=255), nullable=True), + sa.Column('oauth_id', sa.String(length=255), nullable=True), + sa.Column('oauth_token', sa.String(length=255), nullable=True), + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.Column('updated_at', sa.DateTime(timezone=True), nullable=False), + sa.ForeignKeyConstraint(['user_id'], ['user.id'], ), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('user_id', 'provider', name='uq_oauth_user_provider') + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('oauth') + op.drop_table('user') + # ### end Alembic commands ### diff --git a/app/core/configs.py b/app/core/configs.py index bd938c0..d2037dd 100644 --- a/app/core/configs.py +++ b/app/core/configs.py @@ -12,7 +12,7 @@ class ENVIRONMENT(Enum): class Configs(BaseSettings): - ENV: ENVIRONMENT + ENV: ENVIRONMENT = ENVIRONMENT.TEST # --------- APP SETTINGS --------- # PROJECT_NAME: str diff --git a/docs/alembic.md b/docs/alembic.md index 1d53a98..b96256d 100644 --- a/docs/alembic.md +++ b/docs/alembic.md @@ -25,3 +25,144 @@ $ isort alembic && black alembic ``` + +## Migration + +### Revision + +```shell +$ make alembic revision="init: alembic" +Resolved 75 packages in 0.69ms +Audited 41 packages in 0.01ms +INFO [sqlalchemy.engine.Engine] select pg_catalog.version() +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [sqlalchemy.engine.Engine] select current_schema() +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [sqlalchemy.engine.Engine] show standard_conforming_strings +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [alembic.runtime.migration] Context impl PostgresqlImpl. +INFO [alembic.runtime.migration] Will assume transactional DDL. +INFO [sqlalchemy.engine.Engine] BEGIN (implicit) +INFO [sqlalchemy.engine.Engine] SELECT pg_catalog.pg_class.relname +FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_catalog.pg_namespace.oid = pg_catalog.pg_class.relnamespace +WHERE pg_catalog.pg_class.relname = $1::VARCHAR AND pg_catalog.pg_class.relkind = ANY (ARRAY[$2::VARCHAR, $3::VARCHAR, $4::VARCHAR, $5::VARCHAR, $6::VARCHAR]) AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid) AND pg_catalog.pg_namespace.nspname != $7::VARCHAR +INFO [sqlalchemy.engine.Engine] [generated in 0.00010s] ('alembic_version', 'r', 'p', 'f', 'v', 'm', 'pg_catalog') +INFO [sqlalchemy.engine.Engine] SELECT alembic_version.version_num +FROM alembic_version +INFO [sqlalchemy.engine.Engine] [generated in 0.00006s] () +INFO [sqlalchemy.engine.Engine] SELECT pg_catalog.pg_class.relname +FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_catalog.pg_namespace.oid = pg_catalog.pg_class.relnamespace +WHERE pg_catalog.pg_class.relname = $1::VARCHAR AND pg_catalog.pg_class.relkind = ANY (ARRAY[$2::VARCHAR, $3::VARCHAR, $4::VARCHAR, $5::VARCHAR, $6::VARCHAR]) AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid) AND pg_catalog.pg_namespace.nspname != $7::VARCHAR +INFO [sqlalchemy.engine.Engine] [cached since 0.002318s ago] ('alembic_version', 'r', 'p', 'f', 'v', 'm', 'pg_catalog') +INFO [sqlalchemy.engine.Engine] SELECT pg_catalog.pg_class.relname +FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_catalog.pg_namespace.oid = pg_catalog.pg_class.relnamespace +WHERE pg_catalog.pg_class.relkind = ANY (ARRAY[$1::VARCHAR, $2::VARCHAR]) AND pg_catalog.pg_class.relpersistence != $3::CHAR AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid) AND pg_catalog.pg_namespace.nspname != $4::VARCHAR +INFO [sqlalchemy.engine.Engine] [generated in 0.00007s] ('r', 'p', 't', 'pg_catalog') +INFO [alembic.autogenerate.compare] Detected added table 'user' +INFO [alembic.autogenerate.compare] Detected added table 'oauth' +INFO [sqlalchemy.engine.Engine] COMMIT + Generating /home/zerohertz/workspace/alembic/versions/0bdf3abd5213_init_alembic.py ... done +``` + +### Upgrade + +```shell +$ make alembic +Resolved 75 packages in 0.67ms +Audited 41 packages in 0.01ms +INFO [sqlalchemy.engine.Engine] select pg_catalog.version() +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [sqlalchemy.engine.Engine] select current_schema() +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [sqlalchemy.engine.Engine] show standard_conforming_strings +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [alembic.runtime.migration] Context impl PostgresqlImpl. +INFO [alembic.runtime.migration] Will assume transactional DDL. +INFO [sqlalchemy.engine.Engine] BEGIN (implicit) +INFO [sqlalchemy.engine.Engine] SELECT pg_catalog.pg_class.relname +FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_catalog.pg_namespace.oid = pg_catalog.pg_class.relnamespace +WHERE pg_catalog.pg_class.relname = $1::VARCHAR AND pg_catalog.pg_class.relkind = ANY (ARRAY[$2::VARCHAR, $3::VARCHAR, $4::VARCHAR, $5::VARCHAR, $6::VARCHAR]) AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid) AND pg_catalog.pg_namespace.nspname != $7::VARCHAR +INFO [sqlalchemy.engine.Engine] [generated in 0.00011s] ('alembic_version', 'r', 'p', 'f', 'v', 'm', 'pg_catalog') +INFO [sqlalchemy.engine.Engine] SELECT alembic_version.version_num +FROM alembic_version +INFO [sqlalchemy.engine.Engine] [generated in 0.00007s] () +INFO [sqlalchemy.engine.Engine] SELECT pg_catalog.pg_class.relname +FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_catalog.pg_namespace.oid = pg_catalog.pg_class.relnamespace +WHERE pg_catalog.pg_class.relname = $1::VARCHAR AND pg_catalog.pg_class.relkind = ANY (ARRAY[$2::VARCHAR, $3::VARCHAR, $4::VARCHAR, $5::VARCHAR, $6::VARCHAR]) AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid) AND pg_catalog.pg_namespace.nspname != $7::VARCHAR +INFO [sqlalchemy.engine.Engine] [cached since 0.002368s ago] ('alembic_version', 'r', 'p', 'f', 'v', 'm', 'pg_catalog') +INFO [alembic.runtime.migration] Running upgrade -> 0bdf3abd5213, init: alembic +INFO [sqlalchemy.engine.Engine] CREATE TYPE role AS ENUM ('ADMIN', 'USER') +INFO [sqlalchemy.engine.Engine] [no key 0.00005s] () +INFO [sqlalchemy.engine.Engine] +CREATE TABLE "user" ( + name VARCHAR(255) NOT NULL, + email VARCHAR(255) NOT NULL, + role role NOT NULL, + refresh_token VARCHAR(255), + id SERIAL NOT NULL, + created_at TIMESTAMP WITH TIME ZONE NOT NULL, + updated_at TIMESTAMP WITH TIME ZONE NOT NULL, + PRIMARY KEY (id), + UNIQUE (email), + UNIQUE (name) +) + + +INFO [sqlalchemy.engine.Engine] [no key 0.00005s] () +INFO [sqlalchemy.engine.Engine] CREATE TYPE oauthprovider AS ENUM ('PASSWORD', 'GITHUB', 'GOOGLE') +INFO [sqlalchemy.engine.Engine] [no key 0.00006s] () +INFO [sqlalchemy.engine.Engine] +CREATE TABLE oauth ( + user_id INTEGER NOT NULL, + provider oauthprovider NOT NULL, + password VARCHAR(255), + oauth_id VARCHAR(255), + oauth_token VARCHAR(255), + id SERIAL NOT NULL, + created_at TIMESTAMP WITH TIME ZONE NOT NULL, + updated_at TIMESTAMP WITH TIME ZONE NOT NULL, + PRIMARY KEY (id), + FOREIGN KEY(user_id) REFERENCES "user" (id), + CONSTRAINT uq_oauth_user_provider UNIQUE (user_id, provider) +) + + +INFO [sqlalchemy.engine.Engine] [no key 0.00005s] () +INFO [sqlalchemy.engine.Engine] INSERT INTO alembic_version (version_num) VALUES ('0bdf3abd5213') RETURNING alembic_version.version_num +INFO [sqlalchemy.engine.Engine] [generated in 0.00007s] () +INFO [sqlalchemy.engine.Engine] COMMIT +``` + +### Downgrade + +```shell +$ make alembic revision=downgrade +Resolved 75 packages in 0.68ms +Audited 41 packages in 0.01ms +INFO [sqlalchemy.engine.Engine] select pg_catalog.version() +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [sqlalchemy.engine.Engine] select current_schema() +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [sqlalchemy.engine.Engine] show standard_conforming_strings +INFO [sqlalchemy.engine.Engine] [raw sql] () +INFO [alembic.runtime.migration] Context impl PostgresqlImpl. +INFO [alembic.runtime.migration] Will assume transactional DDL. +INFO [sqlalchemy.engine.Engine] BEGIN (implicit) +INFO [sqlalchemy.engine.Engine] SELECT pg_catalog.pg_class.relname +FROM pg_catalog.pg_class JOIN pg_catalog.pg_namespace ON pg_catalog.pg_namespace.oid = pg_catalog.pg_class.relnamespace +WHERE pg_catalog.pg_class.relname = $1::VARCHAR AND pg_catalog.pg_class.relkind = ANY (ARRAY[$2::VARCHAR, $3::VARCHAR, $4::VARCHAR, $5::VARCHAR, $6::VARCHAR]) AND pg_catalog.pg_table_is_visible(pg_catalog.pg_class.oid) AND pg_catalog.pg_namespace.nspname != $7::VARCHAR +INFO [sqlalchemy.engine.Engine] [generated in 0.00011s] ('alembic_version', 'r', 'p', 'f', 'v', 'm', 'pg_catalog') +INFO [sqlalchemy.engine.Engine] SELECT alembic_version.version_num +FROM alembic_version +INFO [sqlalchemy.engine.Engine] [generated in 0.00006s] () +INFO [alembic.runtime.migration] Running downgrade 0bdf3abd5213 -> , init: alembic +INFO [sqlalchemy.engine.Engine] +DROP TABLE oauth +INFO [sqlalchemy.engine.Engine] [no key 0.00004s] () +INFO [sqlalchemy.engine.Engine] +DROP TABLE "user" +INFO [sqlalchemy.engine.Engine] [no key 0.00004s] () +INFO [sqlalchemy.engine.Engine] DELETE FROM alembic_version WHERE alembic_version.version_num = '0bdf3abd5213' +INFO [sqlalchemy.engine.Engine] [generated in 0.00007s] () +INFO [sqlalchemy.engine.Engine] COMMIT +``` diff --git a/envs/test.env b/envs/test.env index e9c847c..28f4c35 100644 --- a/envs/test.env +++ b/envs/test.env @@ -1,5 +1,3 @@ -ENV="TEST" - PORT="8000" PROJECT_NAME="Zerohertz's FastAPI Cookbook (test)" diff --git a/k8s/postgresql/configmap.yaml b/k8s/postgresql/configmap.yaml index bda30cb..05aea89 100644 --- a/k8s/postgresql/configmap.yaml +++ b/k8s/postgresql/configmap.yaml @@ -4,7 +4,6 @@ metadata: name: fastapi-env data: dev.env: | - ENV="DEV" PORT="8000" PROJECT_NAME="Zerohertz's FastAPI Cookbook (dev)" VERSION="v0.1.1" @@ -13,7 +12,6 @@ data: DB_ECHO=true DB_TABLE_CREATE=true prod.env: | - ENV="PROD" PORT="8000" PROJECT_NAME="Zerohertz's FastAPI Cookbook (prod)" VERSION="v0.1.1" diff --git a/k8s/postgresql/fastapi.yaml b/k8s/postgresql/fastapi.yaml index 4cae048..ed0c36a 100644 --- a/k8s/postgresql/fastapi.yaml +++ b/k8s/postgresql/fastapi.yaml @@ -16,6 +16,8 @@ spec: - name: fastapi image: zerohertzkr/fastapi-cookbook:v0.1.2 env: + - name: ENV + value: "PROD" - name: DB_TYPE valueFrom: configMapKeyRef: