future-framework 2.1.1__tar.gz → 3.0.0__tar.gz

{future_framework-2.1.1 → future_framework-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: future-framework
-Version: 2.1.1
+Version: 3.0.0
 Summary: ASGI-based framework for web APIs
 License: LICENSE
 License-File: LICENSE

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/ClickhouseDatabase.py

@@ -123,23 +123,7 @@ class ClickhouseDatabase(IDatabase):
         definitions = []
         order_by = "tuple()"
         for column in blueprint.columns:
-            if column.type == "string":
-                ch_type = "String"
-            elif column.type == "text":
-                ch_type = "String"
-            elif column.type == "integer":
-                ch_type = "Int64"
-            elif column.type == "float":
-                ch_type = "Float64"
-            elif column.type == "boolean":
-                ch_type = "UInt8"
-            elif column.type == "datetime":
-                ch_type = "DateTime"
-            else:
-                raise ValueError(f"Unsupported column type: {column.type}")
-            if column.is_nullable:
-                ch_type = f"Nullable({ch_type})"
-            definitions.append(f"`{column.name}` {ch_type}")
+            definitions.append(self._column_definition(column))
             if column.is_primary:
                 order_by = f"`{column.name}`"
         create_sql = f"CREATE TABLE IF NOT EXISTS `{blueprint.name}` ({', '.join(definitions)}) ENGINE = MergeTree() ORDER BY {order_by}"
@@ -147,6 +131,53 @@ class ClickhouseDatabase(IDatabase):
             await cursor.execute(create_sql)
         return {"status": "created", "table": blueprint.name}
 
+    def _column_type(self, column):
+        if column.type in ("string", "text"):
+            ch_type = "String"
+        elif column.type == "integer":
+            ch_type = "Int64"
+        elif column.type == "float":
+            ch_type = "Float64"
+        elif column.type == "boolean":
+            ch_type = "UInt8"
+        elif column.type == "datetime":
+            ch_type = "DateTime"
+        else:
+            raise ValueError(f"Unsupported column type: {column.type}")
+        return f"Nullable({ch_type})" if column.is_nullable else ch_type
+
+    def _column_definition(self, column):
+        default = f" DEFAULT {column.default_value!r}" if column.default_value is not None else ""
+        return f"`{column.name}` {self._column_type(column)}{default}"
+
+    async def table_exists(self, name):
+        if self.client is None:
+            await self.connect()
+        async with self.client.cursor() as cursor:
+            await cursor.execute("SELECT count() FROM system.tables WHERE database = currentDatabase() AND name = %(name)s", {"name": name})
+            rows = await cursor.fetchall()
+        return bool(rows and rows[0][0])
+
+    async def schema_update(self, blueprint):
+        if self.client is None:
+            await self.connect()
+        if not await self.table_exists(blueprint.name):
+            return await self.schema_create(blueprint)
+        async with self.client.cursor() as cursor:
+            await cursor.execute("SELECT name, type FROM system.columns WHERE database = currentDatabase() AND table = %(table)s", {"table": blueprint.name})
+            rows = await cursor.fetchall()
+            existing = {row[0]: row[1] for row in rows}
+            desired = {column.name: column for column in blueprint.columns}
+            for name, column in desired.items():
+                definition = self._column_definition(column)
+                if name not in existing:
+                    await cursor.execute(f"ALTER TABLE `{blueprint.name}` ADD COLUMN {definition}")
+                elif existing[name] != self._column_type(column):
+                    await cursor.execute(f"ALTER TABLE `{blueprint.name}` MODIFY COLUMN {definition}")
+            for name in existing.keys() - desired.keys():
+                await cursor.execute(f"ALTER TABLE `{blueprint.name}` DROP COLUMN `{name}`")
+        return {"status": "updated", "table": blueprint.name, "columns": sorted(desired)}
+
     async def schema_drop(self, name):
         if self.client is None:
             await self.connect()

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/ElasticsearchDatabase.py

@@ -115,6 +115,13 @@ class ElasticsearchDatabase(IDatabase):
     async def schema_create(self, blueprint):
         if self.client is None:
             await self.connect()
+        properties = self._mapping_properties(blueprint)
+        if await self.client.indices.exists(index=blueprint.name):
+            return {"status": "exists", "index": blueprint.name}
+        result = await self.client.indices.create(index=blueprint.name, mappings={"properties": properties})
+        return result
+
+    def _mapping_properties(self, blueprint):
         properties = {}
         for column in blueprint.columns:
             if column.type == "string" and (column.is_primary or column.name == "id"):
@@ -133,10 +140,35 @@ class ElasticsearchDatabase(IDatabase):
                 properties[column.name] = {"type": "date"}
             else:
                 raise ValueError(f"Unsupported column type: {column.type}")
-        if await self.client.indices.exists(index=blueprint.name):
-            return {"status": "exists", "index": blueprint.name}
-        result = await self.client.indices.create(index=blueprint.name, mappings={"properties": properties})
-        return result
+        return properties
+
+    async def schema_update(self, blueprint):
+        if self.client is None:
+            await self.connect()
+        if not await self.client.indices.exists(index=blueprint.name):
+            return await self.schema_create(blueprint)
+        desired = self._mapping_properties(blueprint)
+        mapping = await self.client.indices.get_mapping(index=blueprint.name)
+        current = mapping.get(blueprint.name, {}).get("mappings", {}).get("properties", {})
+        if current == desired:
+            return {"status": "unchanged", "index": blueprint.name}
+        additive = set(current).issubset(desired) and all(current[name] == desired[name] for name in current)
+        if additive:
+            await self.client.indices.put_mapping(index=blueprint.name, properties=desired)
+            return {"status": "updated", "index": blueprint.name, "properties": sorted(desired)}
+
+        temporary = f"_future_migrate_{blueprint.name}"
+        if await self.client.indices.exists(index=temporary):
+            await self.client.indices.delete(index=temporary)
+        await self.client.indices.create(index=temporary, mappings={"dynamic": False, "properties": desired})
+        keep = list(desired)
+        script = {"source": "ctx._source.keySet().removeIf(k -> !params.keep.contains(k))", "params": {"keep": keep}}
+        await self.client.reindex(body={"source": {"index": blueprint.name}, "dest": {"index": temporary}, "script": script}, wait_for_completion=True, refresh=True)
+        await self.client.indices.delete(index=blueprint.name)
+        await self.client.indices.create(index=blueprint.name, mappings={"dynamic": False, "properties": desired})
+        await self.client.reindex(body={"source": {"index": temporary}, "dest": {"index": blueprint.name}}, wait_for_completion=True, refresh=True)
+        await self.client.indices.delete(index=temporary)
+        return {"status": "updated", "index": blueprint.name, "properties": sorted(desired)}
 
     async def schema_drop(self, name):
         if self.client is None:

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/MongoDBDatabase.py

@@ -108,6 +108,14 @@ class MongoDBDatabase(IDatabase):
     async def schema_create(self, blueprint):
         if self.db is None:
             await self.connect()
+        validator = self._validator(blueprint)
+        if blueprint.name in await self.db.list_collection_names():
+            return {"status": "exists", "collection": blueprint.name}
+        await self.db.create_collection(blueprint.name, validator=validator)
+        await self._ensure_indexes(blueprint)
+        return {"status": "created", "collection": blueprint.name}
+
+    def _validator(self, blueprint):
         properties = {}
         required = []
         for column in blueprint.columns:
@@ -129,15 +137,29 @@ class MongoDBDatabase(IDatabase):
         validator = {"$jsonSchema": {"bsonType": "object", "properties": properties}}
         if required:
             validator["$jsonSchema"]["required"] = required
-        if blueprint.name in await self.db.list_collection_names():
-            return {"status": "exists", "collection": blueprint.name}
-        await self.db.create_collection(blueprint.name, validator=validator)
+        return validator
+
+    async def _ensure_indexes(self, blueprint):
         for column in blueprint.columns:
             if column.is_unique or column.is_primary:
                 await self.db[blueprint.name].create_index(column.name, unique=True)
             elif column.is_index:
                 await self.db[blueprint.name].create_index(column.name)
-        return {"status": "created", "collection": blueprint.name}
+
+    async def table_exists(self, name):
+        if self.db is None:
+            await self.connect()
+        return name in await self.db.list_collection_names()
+
+    async def schema_update(self, blueprint):
+        if self.db is None:
+            await self.connect()
+        if not await self.table_exists(blueprint.name):
+            return await self.schema_create(blueprint)
+        validator = self._validator(blueprint)
+        await self.db.command({"collMod": blueprint.name, "validator": validator})
+        await self._ensure_indexes(blueprint)
+        return {"status": "updated", "collection": blueprint.name, "properties": sorted(column.name for column in blueprint.columns)}
 
     async def schema_drop(self, name):
         if self.db is None:

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/MySQLDatabase.py

@@ -123,6 +123,13 @@ class MySQLDatabase(IDatabase):
     async def schema_create(self, blueprint):
         if self.client is None:
             await self.connect()
+        parts = self._schema_parts(blueprint)
+        create_sql = text(f"CREATE TABLE IF NOT EXISTS `{blueprint.name}` ({', '.join(parts)})")
+        async with self.client.begin() as connection:
+            await connection.execute(create_sql)
+        return {"status": "created", "table": blueprint.name}
+
+    def _schema_parts(self, blueprint):
         definitions = []
         uniques = []
         indexes = []
@@ -154,11 +161,31 @@ class MySQLDatabase(IDatabase):
                 uniques.append(f"UNIQUE KEY `unique_{column.name}` (`{column.name}`)")
             if column.is_index and not column.is_primary and not column.is_unique:
                 indexes.append(f"KEY `index_{column.name}` (`{column.name}`)")
-        parts = definitions + uniques + indexes
-        create_sql = text(f"CREATE TABLE IF NOT EXISTS `{blueprint.name}` ({', '.join(parts)})")
+        return definitions + uniques + indexes
+
+    async def schema_update(self, blueprint):
+        if self.client is None:
+            await self.connect()
+        if not await self.table_exists(blueprint.name):
+            return await self.schema_create(blueprint)
+        sql = text("SELECT COLUMN_NAME FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = :table ORDER BY ORDINAL_POSITION")
+        async with self.client.connect() as connection:
+            rows = (await connection.execute(sql, {"table": blueprint.name})).mappings().all()
+        existing = {row["COLUMN_NAME"] for row in rows}
+        common = [column.name for column in blueprint.columns if column.name in existing]
+        temporary = f"_future_migrate_{blueprint.name}"
+        backup = f"_future_backup_{blueprint.name}"
+        parts = self._schema_parts(blueprint)
         async with self.client.begin() as connection:
-            await connection.execute(create_sql)
-        return {"status": "created", "table": blueprint.name}
+            await connection.execute(text(f"DROP TABLE IF EXISTS `{temporary}`"))
+            await connection.execute(text(f"DROP TABLE IF EXISTS `{backup}`"))
+            await connection.execute(text(f"CREATE TABLE `{temporary}` ({', '.join(parts)})"))
+            if common:
+                columns = ", ".join(f"`{name}`" for name in common)
+                await connection.execute(text(f"INSERT INTO `{temporary}` ({columns}) SELECT {columns} FROM `{blueprint.name}`"))
+            await connection.execute(text(f"RENAME TABLE `{blueprint.name}` TO `{backup}`, `{temporary}` TO `{blueprint.name}`"))
+            await connection.execute(text(f"DROP TABLE `{backup}`"))
+        return {"status": "updated", "table": blueprint.name, "columns": sorted(column.name for column in blueprint.columns)}
 
     async def schema_drop(self, name):
         if self.client is None:

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/PostgresDatabase.py

@@ -3,6 +3,7 @@ from sqlalchemy import BigInteger, String, bindparam, text
 from sqlalchemy.dialects.postgresql import ARRAY
 from sqlalchemy.ext.asyncio import create_async_engine
 from urllib.parse import quote_plus
+from uuid import uuid4
 
 
 class PostgresDatabase(IDatabase):
@@ -128,6 +129,15 @@ class PostgresDatabase(IDatabase):
     async def schema_create(self, blueprint):
         if self.client is None:
             await self.connect()
+        parts, indexes = self._schema_parts(blueprint)
+        create_sql = text(f"CREATE TABLE IF NOT EXISTS \"{blueprint.name}\" ({', '.join(parts)})")
+        async with self.client.begin() as connection:
+            await connection.execute(create_sql)
+            for index_name in indexes:
+                await connection.execute(text(f"CREATE INDEX IF NOT EXISTS \"index_{blueprint.name}_{index_name}\" ON \"{blueprint.name}\" (\"{index_name}\")"))
+        return {"status": "created", "table": blueprint.name}
+
+    def _schema_parts(self, blueprint):
         definitions = []
         uniques = []
         indexes = []
@@ -159,13 +169,31 @@ class PostgresDatabase(IDatabase):
                 uniques.append(f"UNIQUE (\"{column.name}\")")
             if column.is_index and not column.is_primary and not column.is_unique:
                 indexes.append(column.name)
-        parts = definitions + uniques
-        create_sql = text(f"CREATE TABLE IF NOT EXISTS \"{blueprint.name}\" ({', '.join(parts)})")
+        return definitions + uniques, indexes
+
+    async def schema_update(self, blueprint):
+        if self.client is None:
+            await self.connect()
+        if not await self.table_exists(blueprint.name):
+            return await self.schema_create(blueprint)
+        sql = text("SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = :table ORDER BY ordinal_position")
+        async with self.client.connect() as connection:
+            rows = (await connection.execute(sql, {"table": blueprint.name})).mappings().all()
+        existing = {row["column_name"] for row in rows}
+        common = [column.name for column in blueprint.columns if column.name in existing]
+        temporary = f"_future_{uuid4().hex[:8]}_{blueprint.name}"[:63]
+        parts, indexes = self._schema_parts(blueprint)
         async with self.client.begin() as connection:
-            await connection.execute(create_sql)
+            await connection.execute(text(f'DROP TABLE IF EXISTS "{temporary}"'))
+            await connection.execute(text(f'CREATE TABLE "{temporary}" ({", ".join(parts)})'))
+            if common:
+                columns = ", ".join(f'"{name}"' for name in common)
+                await connection.execute(text(f'INSERT INTO "{temporary}" ({columns}) SELECT {columns} FROM "{blueprint.name}"'))
+            await connection.execute(text(f'DROP TABLE "{blueprint.name}"'))
+            await connection.execute(text(f'ALTER TABLE "{temporary}" RENAME TO "{blueprint.name}"'))
             for index_name in indexes:
                 await connection.execute(text(f"CREATE INDEX IF NOT EXISTS \"index_{blueprint.name}_{index_name}\" ON \"{blueprint.name}\" (\"{index_name}\")"))
-        return {"status": "created", "table": blueprint.name}
+        return {"status": "updated", "table": blueprint.name, "columns": sorted(column.name for column in blueprint.columns)}
 
     async def schema_drop(self, name):
         if self.client is None:

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/RedisDatabase.py

@@ -27,6 +27,12 @@ class RedisDatabase(IDatabase):
     def _ids_key(self, table):
         return f"{table}:ids"
 
+    def _schema_key(self, table):
+        return f"future:schema:{table}"
+
+    def _migrations_key(self):
+        return "future:migrations"
+
     async def save(self, model):
         if self.client is None:
             await self.connect()
@@ -125,22 +131,76 @@ class RedisDatabase(IDatabase):
         return {"status": "updated", "id": doc_id}
 
     async def schema_create(self, blueprint):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        schema = self._schema_document(blueprint)
+        created = await self.client.set(self._schema_key(blueprint.name), json.dumps(schema, sort_keys=True, default=str), nx=True)
+        return {"status": "created" if created else "exists", "table": blueprint.name}
+
+    def _schema_document(self, blueprint):
+        return {
+            "name": blueprint.name,
+            "columns": [
+                {
+                    "name": column.name,
+                    "type": column.type,
+                    "length": column.length,
+                    "nullable": column.is_nullable,
+                    "unique": column.is_unique,
+                    "primary": column.is_primary,
+                    "index": column.is_index,
+                    "default": column.default_value,
+                }
+                for column in blueprint.columns
+            ],
+        }
+
+    async def table_exists(self, name):
+        if self.client is None:
+            await self.connect()
+        return bool(await self.client.exists(self._schema_key(name)))
+
+    async def schema_update(self, blueprint):
+        if self.client is None:
+            await self.connect()
+        await self.client.set(self._schema_key(blueprint.name), json.dumps(self._schema_document(blueprint), sort_keys=True, default=str))
+        return {"status": "updated", "table": blueprint.name, "columns": sorted(column.name for column in blueprint.columns)}
 
     async def schema_drop(self, name):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        ids = await self.client.smembers(self._ids_key(name))
+        keys = [self._key(name, doc_id) for doc_id in ids]
+        keys.extend([self._ids_key(name), self._schema_key(name)])
+        if keys:
+            await self.client.delete(*keys)
+        return {"status": "dropped", "table": name}
 
     async def migrations_get(self):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        return list(await self.client.zrange(self._migrations_key(), 0, -1))
 
     async def migrations_put(self, name, batch):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        await self.client.zadd(self._migrations_key(), {name: int(batch)})
 
     async def migrations_delete(self, name):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        await self.client.zrem(self._migrations_key(), name)
 
     async def migrations_max_batch(self):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        rows = await self.client.zrevrange(self._migrations_key(), 0, 0, withscores=True)
+        if not rows:
+            return 0
+        return int(rows[0][1])
 
     async def migrations_batch_for(self, name):
-        raise NotImplementedError("Redis has no schema; structural migrations are unsupported")
+        if self.client is None:
+            await self.connect()
+        score = await self.client.zscore(self._migrations_key(), name)
+        return None if score is None else int(score)

{future_framework-2.1.1 → future_framework-3.0.0}/future/databases/SQLiteDatabase.py

@@ -128,6 +128,15 @@ class SQLiteDatabase(IDatabase):
     async def schema_create(self, blueprint):
         if self.client is None:
             await self.connect()
+        definitions, indexes = self._schema_parts(blueprint)
+        create_sql = text(f'CREATE TABLE IF NOT EXISTS "{blueprint.name}" ({", ".join(definitions)})')
+        async with self.client.begin() as connection:
+            await connection.execute(create_sql)
+            for index_sql in indexes:
+                await connection.execute(text(index_sql))
+        return {"status": "created", "table": blueprint.name}
+
+    def _schema_parts(self, blueprint, index_table=None):
         definitions = []
         indexes = []
         for column in blueprint.columns:
@@ -156,13 +165,34 @@ class SQLiteDatabase(IDatabase):
             unique_sql = " UNIQUE" if column.is_unique and not column.is_primary else ""
             definitions.append(f'"{column.name}" {sql_type} {null_sql}{default_sql}{primary_sql}{unique_sql}')
             if column.is_index and not column.is_primary and not column.is_unique:
-                indexes.append(f'CREATE INDEX IF NOT EXISTS "index_{blueprint.name}_{column.name}" ON "{blueprint.name}" ("{column.name}")')
-        create_sql = text(f'CREATE TABLE IF NOT EXISTS "{blueprint.name}" ({", ".join(definitions)})')
+                table = index_table or blueprint.name
+                indexes.append(f'CREATE INDEX IF NOT EXISTS "index_{table}_{column.name}" ON "{table}" ("{column.name}")')
+        return definitions, indexes
+
+    async def schema_update(self, blueprint):
+        if self.client is None:
+            await self.connect()
+        if not await self.table_exists(blueprint.name):
+            return await self.schema_create(blueprint)
+        async with self.client.connect() as connection:
+            rows = (await connection.execute(text(f'PRAGMA table_info("{blueprint.name}")'))).mappings().all()
+        existing = {row["name"] for row in rows}
+        desired = {column.name for column in blueprint.columns}
+        common = [column.name for column in blueprint.columns if column.name in existing]
+        temporary = f"_future_migrate_{blueprint.name}"
+        definitions, _ = self._schema_parts(blueprint)
+        _, indexes = self._schema_parts(blueprint, index_table=blueprint.name)
         async with self.client.begin() as connection:
-            await connection.execute(create_sql)
+            await connection.execute(text(f'DROP TABLE IF EXISTS "{temporary}"'))
+            await connection.execute(text(f'CREATE TABLE "{temporary}" ({", ".join(definitions)})'))
+            if common:
+                columns = ", ".join(f'"{name}"' for name in common)
+                await connection.execute(text(f'INSERT INTO "{temporary}" ({columns}) SELECT {columns} FROM "{blueprint.name}"'))
+            await connection.execute(text(f'DROP TABLE "{blueprint.name}"'))
+            await connection.execute(text(f'ALTER TABLE "{temporary}" RENAME TO "{blueprint.name}"'))
             for index_sql in indexes:
                 await connection.execute(text(index_sql))
-        return {"status": "created", "table": blueprint.name}
+        return {"status": "updated", "table": blueprint.name, "columns": sorted(desired)}
 
     async def schema_drop(self, name):
         if self.client is None:

{future_framework-2.1.1 → future_framework-3.0.0}/future/interfaces/IDatabase.py

@@ -40,6 +40,9 @@ class IDatabase(Interface):
     async def schema_create(self, blueprint):
         raise NotImplementedError
 
+    async def schema_update(self, blueprint):
+        raise NotImplementedError
+
     async def schema_drop(self, name):
         raise NotImplementedError
 

{future_framework-2.1.1 → future_framework-3.0.0}/future/migrations.py

@@ -1,6 +1,7 @@
 # Migrations — Orator/Masonite-style schema, discovery, and generation.
 
 
+import ast
 import importlib.util
 import inflection
 
@@ -71,6 +72,8 @@ class Blueprint:
         connection = Database().get_connection(self.connection_name)
         if self.action == "create":
             await connection.schema_create(self)
+        elif self.action == "update":
+            await connection.schema_update(self)
         return False
 
     def _add(self, column):
@@ -112,6 +115,9 @@ class SchemaMeta(type):
     def create(cls, name):
         return Blueprint(name, cls._connection_name, action="create")
 
+    def update(cls, name):
+        return Blueprint(name, cls._connection_name, action="update")
+
     async def drop(cls, name):
         await Database().get_connection(cls._connection_name).schema_drop(name)
 
@@ -267,12 +273,49 @@ class MigrationGenerator:
             lines.append("            table.timestamps()")
         return lines
 
-    def render(self, model):
+    def _schema_call(self, node, table):
+        if not isinstance(node, ast.Call) or not isinstance(node.func, ast.Attribute):
+            return False
+        if node.func.attr not in ("create", "update") or not isinstance(node.func.value, ast.Name) or node.func.value.id != "Schema":
+            return False
+        return bool(node.args and isinstance(node.args[0], ast.Constant) and node.args[0].value == table)
+
+    def _previous_blueprint_lines(self, table):
+        directory = Path(self.migrations_path)
+        if not directory.exists():
+            return None
+        for path in reversed(sorted(directory.glob("*.py"))):
+            try:
+                source = path.read_text()
+                tree = ast.parse(source)
+            except (OSError, SyntaxError):
+                continue
+            for node in ast.walk(tree):
+                if not isinstance(node, ast.AsyncFunctionDef) or node.name != "up":
+                    continue
+                for statement in node.body:
+                    if not isinstance(statement, ast.AsyncWith):
+                        continue
+                    if not statement.items or not self._schema_call(statement.items[0].context_expr, table):
+                        continue
+                    lines = []
+                    for item in statement.body:
+                        if not isinstance(item, ast.Expr) or not isinstance(item.value, ast.Call):
+                            continue
+                        expression = (ast.get_source_segment(source, item) or ast.unparse(item)).strip()
+                        if expression.startswith("table."):
+                            lines.append(f"            {expression}")
+                    return lines
+        return None
+
+    def render(self, model, previous_lines=None):
         table = self.table_name(model)
-        class_name = f"Create{inflection.camelize(table)}"
+        is_update = previous_lines is not None
+        action = "update" if is_update else "create"
+        class_name = f"{'Update' if is_update else 'Create'}{inflection.camelize(table)}"
         connection = getattr(model, "__connection__", "default")
         columns = "\n".join(self.blueprint_lines(model))
-        return (
+        rendered = (
             "from future.migrations import Migration, Schema\n"
             "\n"
             "\n"
@@ -280,12 +323,14 @@ class MigrationGenerator:
             f'    __connection__ = "{connection}"\n'
             "\n"
             "    async def up(self):\n"
-            f'        async with Schema.create("{table}") as table:\n'
+            f'        async with Schema.{action}("{table}") as table:\n'
             f"{columns}\n"
             "\n"
-            "    async def down(self):\n"
-            f'        await Schema.drop("{table}")\n'
         )
+        if not is_update:
+            return rendered + "    async def down(self):\n" + f'        await Schema.drop("{table}")\n'
+        previous = "\n".join(previous_lines)
+        return rendered + "    async def down(self):\n" + f'        async with Schema.update("{table}") as table:\n' + f"{previous}\n"
 
     def make(self, model_name=None):
         if model_name is None:
@@ -301,12 +346,17 @@ class MigrationGenerator:
 
     def write(self, model, stamp_offset=0):
         table = self.table_name(model)
-        stamp = datetime.now().strftime("%Y_%m_%d_%H%M%S")
+        previous_lines = self._previous_blueprint_lines(table)
+        action = "update" if previous_lines is not None else "create"
+        stamp = datetime.now().strftime("%Y_%m_%d_%H%M%S_%f")
         if stamp_offset:
             stamp = f"{stamp}_{stamp_offset:02d}"
-        file_name = f"{stamp}_create_{table}.py"
         directory = Path(self.migrations_path)
         directory.mkdir(parents=True, exist_ok=True)
-        path = directory / file_name
-        path.write_text(self.render(model))
+        path = directory / f"{stamp}_{action}_{table}.py"
+        collision = 1
+        while path.exists():
+            path = directory / f"{stamp}_{collision:02d}_{action}_{table}.py"
+            collision += 1
+        path.write_text(self.render(model, previous_lines=previous_lines))
         return str(path)

{future_framework-2.1.1 → future_framework-3.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "future-framework"
-version = "2.1.1"
+version = "3.0.0"
 description = "ASGI-based framework for web APIs"
 authors = ["nicolaipre"]
 license = "LICENSE"