snowflake-cli-labs 3.0.0rc1__py3-none-any.whl → 3.0.0rc2__py3-none-any.whl

snowflake/cli/api/entities/application_package_entity.py

@@ -27,6 +27,7 @@ from snowflake.cli._plugins.nativeapp.exceptions import (
 from snowflake.cli._plugins.nativeapp.utils import (
     needs_confirmation,
 )
+from snowflake.cli._plugins.stage.diff import DiffResult
 from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.workspace.action_context import ActionContext
 from snowflake.cli.api.console.abc import AbstractConsole
@@ -48,6 +49,7 @@ from snowflake.cli.api.project.schemas.entities.application_package_entity_model
     ApplicationPackageEntityModel,
 )
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
+from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import extract_schema
 from snowflake.cli.api.rendering.jinja import (
     get_basic_jinja_env,
@@ -61,22 +63,16 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
     A Native App application package.
     """
 
-    def action_bundle(self, ctx: ActionContext):
+    def action_bundle(self, ctx: ActionContext, *args, **kwargs):
         model = self._entity_model
-        bundle_map = build_bundle(
-            ctx.project_root, Path(model.deploy_root), model.artifacts
-        )
-        bundle_context = BundleContext(
-            package_name=model.identifier,
-            artifacts=model.artifacts,
+        return self.bundle(
             project_root=ctx.project_root,
-            bundle_root=Path(model.bundle_root),
             deploy_root=Path(model.deploy_root),
+            bundle_root=Path(model.bundle_root),
             generated_root=Path(model.generated_root),
+            package_name=model.identifier,
+            artifacts=model.artifacts,
         )
-        compiler = NativeAppCompiler(bundle_context)
-        compiler.compile_artifacts()
-        return bundle_map
 
     def action_deploy(
         self,
@@ -85,7 +81,36 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         recursive: bool,
         paths: List[Path],
         validate: bool,
+        stage_fqn: Optional[str] = None,
+        *args,
+        **kwargs,
     ):
+        model = self._entity_model
+        package_name = model.fqn.identifier
+        return self.deploy(
+            console=ctx.console,
+            project_root=ctx.project_root,
+            deploy_root=Path(model.deploy_root),
+            bundle_root=Path(model.bundle_root),
+            generated_root=Path(model.generated_root),
+            artifacts=model.artifacts,
+            package_name=package_name,
+            package_role=(model.meta and model.meta.role) or ctx.default_role,
+            package_distribution=model.distribution,
+            prune=prune,
+            recursive=recursive,
+            paths=paths,
+            print_diff=True,
+            validate=validate,
+            stage_fqn=stage_fqn or f"{package_name}.{model.stage}",
+            package_warehouse=(
+                (model.meta and model.meta.warehouse) or ctx.default_warehouse
+            ),
+            post_deploy_hooks=model.meta and model.meta.post_deploy,
+            package_scripts=[],  # Package scripts are not supported in PDFv2
+        )
+
+    def action_drop(self, ctx: ActionContext, force_drop: bool, *args, **kwargs):
         model = self._entity_model
         package_name = model.fqn.identifier
         if model.meta and model.meta.role:
@@ -93,24 +118,121 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
         else:
             package_role = ctx.default_role
 
+        self.drop(
+            console=ctx.console,
+            package_name=package_name,
+            package_role=package_role,
+            force_drop=force_drop,
+        )
+
+    def action_validate(self, ctx: ActionContext, *args, **kwargs):
+        model = self._entity_model
+        package_name = model.fqn.identifier
+        stage_fqn = f"{package_name}.{model.stage}"
+        if model.meta and model.meta.role:
+            package_role = model.meta.role
+        else:
+            package_role = ctx.default_role
+
+        def deploy_to_scratch_stage_fn():
+            self.action_deploy(
+                ctx=ctx,
+                prune=True,
+                recursive=True,
+                paths=[],
+                validate=False,
+                stage_fqn=model.scratch_stage,
+            )
+
+        self.validate_setup_script(
+            console=ctx.console,
+            package_name=package_name,
+            package_role=package_role,
+            stage_fqn=stage_fqn,
+            use_scratch_stage=True,
+            scratch_stage_fqn=model.scratch_stage,
+            deploy_to_scratch_stage_fn=deploy_to_scratch_stage_fn,
+        )
+        ctx.console.message("Setup script is valid")
+
+    @staticmethod
+    def bundle(
+        project_root: Path,
+        deploy_root: Path,
+        bundle_root: Path,
+        generated_root: Path,
+        artifacts: list[PathMapping],
+        package_name: str,
+    ):
+        bundle_map = build_bundle(project_root, deploy_root, artifacts)
+        bundle_context = BundleContext(
+            package_name=package_name,
+            artifacts=artifacts,
+            project_root=project_root,
+            bundle_root=bundle_root,
+            deploy_root=deploy_root,
+            generated_root=generated_root,
+        )
+        compiler = NativeAppCompiler(bundle_context)
+        compiler.compile_artifacts()
+        return bundle_map
+
+    @classmethod
+    def deploy(
+        cls,
+        console: AbstractConsole,
+        project_root: Path,
+        deploy_root: Path,
+        bundle_root: Path,
+        generated_root: Path,
+        artifacts: list[PathMapping],
+        package_name: str,
+        package_role: str,
+        package_distribution: str,
+        package_warehouse: str | None,
+        prune: bool,
+        recursive: bool,
+        paths: List[Path],
+        print_diff: bool,
+        validate: bool,
+        stage_fqn: str,
+        post_deploy_hooks: list[PostDeployHook] | None,
+        package_scripts: List[str],
+    ) -> DiffResult:
         # 1. Create a bundle
-        bundle_map = self.action_bundle(ctx)
+        bundle_map = cls.bundle(
+            project_root=project_root,
+            deploy_root=deploy_root,
+            bundle_root=bundle_root,
+            generated_root=generated_root,
+            artifacts=artifacts,
+            package_name=package_name,
+        )
 
         # 2. Create an empty application package, if none exists
-        self.create_app_package(
-            console=ctx.console,
+        cls.create_app_package(
+            console=console,
             package_name=package_name,
             package_role=package_role,
-            package_distribution=model.distribution,
+            package_distribution=package_distribution,
         )
 
         with get_sql_executor().use_role(package_role):
+            if package_scripts:
+                cls.apply_package_scripts(
+                    console=console,
+                    package_scripts=package_scripts,
+                    package_warehouse=package_warehouse,
+                    project_root=project_root,
+                    package_role=package_role,
+                    package_name=package_name,
+                )
+
             # 3. Upload files from deploy root local folder to the above stage
-            stage_fqn = f"{package_name}.{model.stage}"
             stage_schema = extract_schema(stage_fqn)
-            sync_deploy_root_with_stage(
-                console=ctx.console,
-                deploy_root=Path(model.deploy_root),
+            diff = sync_deploy_root_with_stage(
+                console=console,
+                deploy_root=deploy_root,
                 package_name=package_name,
                 stage_schema=stage_schema,
                 bundle_map=bundle_map,
@@ -119,21 +241,21 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 recursive=recursive,
                 stage_fqn=stage_fqn,
                 local_paths_to_sync=paths,
-                print_diff=True,
+                print_diff=print_diff,
             )
 
-        if model.meta and model.meta.post_deploy:
-            self.execute_post_deploy_hooks(
-                console=ctx.console,
-                project_root=ctx.project_root,
-                post_deploy_hooks=model.meta.post_deploy,
+        if post_deploy_hooks:
+            cls.execute_post_deploy_hooks(
+                console=console,
+                project_root=project_root,
+                post_deploy_hooks=post_deploy_hooks,
                 package_name=package_name,
-                package_warehouse=model.meta.warehouse or ctx.default_warehouse,
+                package_warehouse=package_warehouse,
             )
 
         if validate:
-            self.validate_setup_script(
-                console=ctx.console,
+            cls.validate_setup_script(
+                console=console,
                 package_name=package_name,
                 package_role=package_role,
                 stage_fqn=stage_fqn,
@@ -142,24 +264,7 @@ class ApplicationPackageEntity(EntityBase[ApplicationPackageEntityModel]):
                 deploy_to_scratch_stage_fn=lambda *args: None,
             )
 
-    def action_drop(
-        self,
-        ctx: ActionContext,
-        force_drop: bool,
-    ):
-        model = self._entity_model
-        package_name = model.fqn.identifier
-        if model.meta and model.meta.role:
-            package_role = model.meta.role
-        else:
-            package_role = ctx.default_role
-
-        self.drop(
-            console=ctx.console,
-            package_name=package_name,
-            package_role=package_role,
-            force_drop=force_drop,
-        )
+        return diff
 
     @staticmethod
     def get_existing_app_pkg_info(

snowflake/cli/api/entities/common.py

@@ -9,6 +9,7 @@ class EntityActions(str, Enum):
     BUNDLE = "action_bundle"
     DEPLOY = "action_deploy"
     DROP = "action_drop"
+    VALIDATE = "action_validate"
 
 
 T = TypeVar("T")

snowflake/cli/api/entities/utils.py

@@ -40,6 +40,7 @@ from snowflake.cli.api.rendering.sql_templates import (
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 from snowflake.connector import ProgrammingError
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 def generic_sql_error_handler(
@@ -303,27 +304,34 @@ def render_script_templates(
     - List of rendered scripts content
     Size of the return list is the same as the size of the input scripts list.
     """
-    scripts_contents = []
-    for relpath in scripts:
-        script_full_path = SecurePath(project_root) / relpath
-        try:
-            template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
-            env = override_env or choose_sql_jinja_env_based_on_template_syntax(
-                template_content, reference_name=relpath
-            )
-            result = env.from_string(template_content).render(jinja_context)
-            scripts_contents.append(result)
+    return [
+        render_script_template(project_root, jinja_context, script, override_env)
+        for script in scripts
+    ]
 
-        except FileNotFoundError as e:
-            raise MissingScriptError(relpath) from e
 
-        except jinja2.TemplateSyntaxError as e:
-            raise InvalidTemplateInFileError(relpath, e, e.lineno) from e
+def render_script_template(
+    project_root: Path,
+    jinja_context: dict[str, Any],
+    script: str,
+    override_env: Optional[jinja2.Environment] = None,
+) -> str:
+    script_full_path = SecurePath(project_root) / script
+    try:
+        template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
+        env = override_env or choose_sql_jinja_env_based_on_template_syntax(
+            template_content, reference_name=script
+        )
+        return env.from_string(template_content).render(jinja_context)
+
+    except FileNotFoundError as e:
+        raise MissingScriptError(script) from e
 
-        except jinja2.UndefinedError as e:
-            raise InvalidTemplateInFileError(relpath, e) from e
+    except jinja2.TemplateSyntaxError as e:
+        raise InvalidTemplateInFileError(script, e, e.lineno) from e
 
-    return scripts_contents
+    except jinja2.UndefinedError as e:
+        raise InvalidTemplateInFileError(script, e) from e
 
 
 def validation_item_to_str(item: dict[str, str | int]):
@@ -355,3 +363,19 @@ def drop_generic_object(
             raise SnowflakeSQLExecutionError(drop_query)
 
         console.message(f"Dropped {object_type} {object_name} successfully.")
+
+
+def print_messages(
+    console: AbstractConsole, create_or_upgrade_cursor: Optional[SnowflakeCursor]
+):
+    """
+    Shows messages in the console returned by the CREATE or UPGRADE
+    APPLICATION command.
+    """
+    if not create_or_upgrade_cursor:
+        return
+
+    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
+    for message in messages:
+        console.warning(message)
+    console.message("")

snowflake/cli/api/identifiers.py

@@ -184,3 +184,6 @@ class FQN:
         from snowflake.cli.api.cli_global_context import get_cli_context
 
         return self.using_connection(get_cli_context().connection)
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "schema": self.schema, "database": self.database}

snowflake/cli/api/project/definition.py

@@ -23,6 +23,7 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.project_definition import (
     ProjectProperties,
+    YamlOverride,
 )
 from snowflake.cli.api.project.util import (
     append_to_identifier,
@@ -37,6 +38,7 @@ from snowflake.cli.api.utils.definition_rendering import (
 )
 from snowflake.cli.api.utils.dict_utils import deep_merge_dicts
 from snowflake.cli.api.utils.types import Context, Definition
+from yaml import MappingNode, SequenceNode
 
 DEFAULT_USERNAME = "unknown_user"
 
@@ -50,6 +52,7 @@ def _get_merged_definitions(paths: List[Path]) -> Optional[Definition]:
     loader.add_constructor(
         yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _no_duplicates_constructor
     )
+    loader.add_constructor("!override", _override_tag)
 
     with spaths[0].open("r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as base_yml:
         definition = yaml.load(base_yml.read(), Loader=loader) or {}
@@ -113,3 +116,11 @@ def _no_duplicates_constructor(loader, node, deep=False):
             )
         mapping[key] = value
     return loader.construct_mapping(node, deep)
+
+
+def _override_tag(loader, node, deep=False):
+    if isinstance(node, SequenceNode):
+        return YamlOverride(data=loader.construct_sequence(node, deep))
+    if isinstance(node, MappingNode):
+        return YamlOverride(data=loader.construct_mapping(node, deep))
+    return node.value

snowflake/cli/api/project/definition_conversion.py

@@ -1,15 +1,31 @@
+from __future__ import annotations
+
 import logging
 from pathlib import Path
 from typing import Any, Dict, Literal, Optional
 
 from click import ClickException
+from snowflake.cli._plugins.nativeapp.artifacts import (
+    build_bundle,
+)
 from snowflake.cli._plugins.snowpark.common import is_name_a_templated_one
 from snowflake.cli.api.constants import (
     DEFAULT_ENV_FILE,
     DEFAULT_PAGES_DIR,
+    PROJECT_TEMPLATE_VARIABLE_CLOSING,
     PROJECT_TEMPLATE_VARIABLE_OPENING,
     SNOWPARK_SHARED_MIXIN,
 )
+from snowflake.cli.api.entities.utils import render_script_template
+from snowflake.cli.api.project.schemas.entities.common import (
+    SqlScriptHookType,
+)
+from snowflake.cli.api.project.schemas.native_app.application import (
+    Application,
+    ApplicationV11,
+)
+from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
+from snowflake.cli.api.project.schemas.native_app.package import Package, PackageV11
 from snowflake.cli.api.project.schemas.project_definition import (
     ProjectDefinition,
     ProjectDefinitionV2,
@@ -20,23 +36,31 @@ from snowflake.cli.api.project.schemas.snowpark.callable import (
 )
 from snowflake.cli.api.project.schemas.snowpark.snowpark import Snowpark
 from snowflake.cli.api.project.schemas.streamlit.streamlit import Streamlit
+from snowflake.cli.api.rendering.jinja import get_basic_jinja_env
 
 log = logging.getLogger(__name__)
 
 
 def convert_project_definition_to_v2(
-    pd: ProjectDefinition, accept_templates: bool = False
+    project_root: Path, pd: ProjectDefinition, accept_templates: bool = False
 ) -> ProjectDefinitionV2:
     _check_if_project_definition_meets_requirements(pd, accept_templates)
 
     snowpark_data = convert_snowpark_to_v2_data(pd.snowpark) if pd.snowpark else {}
     streamlit_data = convert_streamlit_to_v2_data(pd.streamlit) if pd.streamlit else {}
+    native_app_data = (
+        convert_native_app_to_v2_data(project_root, pd.native_app)
+        if pd.native_app
+        else {}
+    )
     envs = convert_envs_to_v2(pd)
 
     data = {
         "definition_version": "2",
         "entities": get_list_of_all_entities(
-            snowpark_data.get("entities", {}), streamlit_data.get("entities", {})
+            snowpark_data.get("entities", {}),
+            streamlit_data.get("entities", {}),
+            native_app_data.get("entities", {}),
         ),
         "mixins": snowpark_data.get("mixins", None),
         "env": envs,
@@ -99,7 +123,7 @@ def convert_snowpark_to_v2_data(snowpark: Snowpark) -> Dict[str, Any]:
     return data
 
 
-def convert_streamlit_to_v2_data(streamlit: Streamlit):
+def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
     # Process env file and pages dir
     environment_file = _process_streamlit_files(streamlit.env_file, "environment")
     pages_dir = _process_streamlit_files(streamlit.pages_dir, "pages")
@@ -144,6 +168,135 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit):
     return data
 
 
+def convert_native_app_to_v2_data(
+    project_root, native_app: NativeApp
+) -> Dict[str, Any]:
+    def _make_meta(obj: Application | Package):
+        meta = {}
+        if obj.role:
+            meta["role"] = obj.role
+        if obj.warehouse:
+            meta["warehouse"] = obj.warehouse
+        if obj.post_deploy:
+            meta["post_deploy"] = obj.post_deploy
+        return meta
+
+    def _find_manifest():
+        # We don't know which file in the project directory is the actual manifest,
+        # and we can't iterate through the artifacts property since the src can contain
+        # glob patterns. The simplest solution is to bundle the app and find the
+        # manifest file from the resultant BundleMap, since the bundle process ensures
+        # that only a single source path can map to the corresponding destination path
+        try:
+            bundle_map = build_bundle(
+                project_root, Path(native_app.deploy_root), native_app.artifacts
+            )
+        except Exception as e:
+            # The manifest field is required, so we can't gracefully handle bundle failures
+            raise ClickException(
+                f"{e}\nCould not bundle Native App artifacts, unable to perform migration"
+            ) from e
+
+        manifest_path = bundle_map.to_project_path(Path("manifest.yml"))
+        if not manifest_path:
+            # The manifest field is required, so we can't gracefully handle it being missing
+            raise ClickException(
+                "manifest.yml file not found in any Native App artifact sources, "
+                "unable to perform migration"
+            )
+
+        # Use a POSIX path to be consistent with other migrated fields
+        # which use POSIX paths as default values
+        return manifest_path.as_posix()
+
+    def _make_template(template: str) -> str:
+        return f"{PROJECT_TEMPLATE_VARIABLE_OPENING} {template} {PROJECT_TEMPLATE_VARIABLE_CLOSING}"
+
+    def _convert_package_script_files(package_scripts: list[str]):
+        # PDFv2 doesn't support package scripts, only post-deploy scripts, so we
+        # need to convert the Jinja syntax from {{ }} to <% %>
+        # Luckily, package scripts only support {{ package_name }}, so let's convert that tag
+        # to v2 template syntax by running it though the template process with a fake
+        # package name that's actually a valid v2 template, which will be evaluated
+        # when the script is used as a post-deploy script
+        fake_package_replacement_template = _make_template(
+            f"ctx.entities.{package_entity_name}.identifier"
+        )
+        jinja_context = dict(package_name=fake_package_replacement_template)
+        post_deploy_hooks = []
+        for script_file in package_scripts:
+            new_contents = render_script_template(
+                project_root, jinja_context, script_file, get_basic_jinja_env()
+            )
+            (project_root / script_file).write_text(new_contents)
+            post_deploy_hooks.append(SqlScriptHookType(sql_script=script_file))
+        return post_deploy_hooks
+
+    package_entity_name = "pkg"
+    if (
+        native_app.package
+        and native_app.package.name
+        and native_app.package.name != PackageV11.model_fields["name"].default
+    ):
+        package_identifier = native_app.package.name
+    else:
+        # Backport the PackageV11 default name template, updated for PDFv2
+        package_identifier = _make_template(
+            f"fn.concat_ids('{native_app.name}', '_pkg_', fn.sanitize_id(fn.get_username('unknown_user')) | lower)"
+        )
+    package = {
+        "type": "application package",
+        "identifier": package_identifier,
+        "manifest": _find_manifest(),
+        "artifacts": native_app.artifacts,
+        "bundle_root": native_app.bundle_root,
+        "generated_root": native_app.generated_root,
+        "deploy_root": native_app.deploy_root,
+        "stage": native_app.source_stage,
+        "scratch_stage": native_app.scratch_stage,
+    }
+    if native_app.package:
+        package["distribution"] = native_app.package.distribution
+        package_meta = _make_meta(native_app.package)
+        if native_app.package.scripts:
+            converted_post_deploy_hooks = _convert_package_script_files(
+                native_app.package.scripts
+            )
+            package_meta["post_deploy"] = (
+                package_meta.get("post_deploy", []) + converted_post_deploy_hooks
+            )
+        if package_meta:
+            package["meta"] = package_meta
+
+    app_entity_name = "app"
+    if (
+        native_app.application
+        and native_app.application.name
+        and native_app.application.name != ApplicationV11.model_fields["name"].default
+    ):
+        app_identifier = native_app.application.name
+    else:
+        # Backport the ApplicationV11 default name template, updated for PDFv2
+        app_identifier = _make_template(
+            f"fn.concat_ids('{native_app.name}', '_', fn.sanitize_id(fn.get_username('unknown_user')) | lower)"
+        )
+    app = {
+        "type": "application",
+        "identifier": app_identifier,
+        "from": {"target": package_entity_name},
+    }
+    if native_app.application:
+        if app_meta := _make_meta(native_app.application):
+            app["meta"] = app_meta
+
+    return {
+        "entities": {
+            package_entity_name: package,
+            app_entity_name: app,
+        }
+    }
+
+
 def convert_envs_to_v2(pd: ProjectDefinition):
     if hasattr(pd, "env") and pd.env:
         data = {k: v for k, v in pd.env.items()}
@@ -166,10 +319,6 @@ def _check_if_project_definition_meets_requirements(
         log.warning(
             "Your V1 definition contains templates. We cannot guarantee the correctness of the migration."
         )
-    if pd.native_app:
-        raise ClickException(
-            "Your project file contains a native app definition. Conversion of Native apps is not yet supported"
-        )
 
 
 def _process_streamlit_files(
@@ -185,10 +334,19 @@ def _process_streamlit_files(
 
 
 def get_list_of_all_entities(
-    snowpark_entities: Dict[str, Any], streamlit_entities: Dict[str, Any]
+    snowpark_entities: Dict[str, Any],
+    streamlit_entities: Dict[str, Any],
+    native_app_entities: Dict[str, Any],
 ):
-    if snowpark_entities.keys() & streamlit_entities.keys():
-        raise ClickException(
-            "In your project, streamlit and snowpark entities share the same name. Please rename them and try again."
-        )
-    return snowpark_entities | streamlit_entities
+    # Check all combinations of entity types for overlapping names
+    # (No need to use itertools here, PDFv1 only supports these three types)
+    for types, first, second in [
+        ("streamlit and snowpark", streamlit_entities, snowpark_entities),
+        ("streamlit and native app", streamlit_entities, native_app_entities),
+        ("native app and snowpark", native_app_entities, snowpark_entities),
+    ]:
+        if first.keys() & second.keys():
+            raise ClickException(
+                f"In your project, {types} entities share the same name. Please rename them and try again."
+            )
+    return snowpark_entities | streamlit_entities | native_app_entities

snowflake/cli/api/project/schemas/entities/common.py

@@ -61,18 +61,6 @@ class MetaField(UpdatableModel):
         return mixins
 
 
-class DefaultsField(UpdatableModel):
-    schema_: Optional[str] = Field(
-        title="Schema.",
-        alias="schema",
-        default=None,
-    )
-    stage: Optional[str] = Field(
-        title="Stage.",
-        default=None,
-    )
-
-
 class EntityModelBase(ABC, UpdatableModel):
     @classmethod
     def get_type(cls) -> str:

snowflake/cli/api/project/schemas/identifier_model.py

@@ -25,8 +25,8 @@ from snowflake.cli.api.project.schemas.updatable_model import (
 
 class Identifier(UpdatableModel):
     name: str = Field(title="Entity name")
-    schema_: str = Field(title="Entity schema", alias="schema", default=None)
-    database: str = Field(title="Entity database", default=None)
+    schema_: Optional[str] = Field(title="Entity schema", alias="schema", default=None)
+    database: Optional[str] = Field(title="Entity database", default=None)
 
 
 class ObjectIdentifierBaseModel: