collectionNameIsCamelCase

collectionNameIsCamelCase is a custom policy check that ensures collection names use camelCase.

Learn how to create and customize the collectionNameIsCamelCase Liquibase Custom Policy Check using a Python script.

This example utilizes MongoDB or DocumentDB. You can use this check as it is or customize it further to fit your needs in your NoSQL database.

For a conceptual overview of this feature, see Liquibase Pro Custom Policy Checks.

Before you begin

Scope

Database

changelog

MongoDB and DocumentDB

Liquibase Prerequisites

  • Liquibase 4.29.0+

  • Python 3.10.14+

  • Configure a valid Liquibase Pro license key

  • Ensure the Liquibase Checks extension is installed. In Liquibase 4.31.0+, it is already installed in the /liquibase/internal/lib directory, so no action is needed.

  • If the checks JAR is not installed, download liquibase-checks-<version>.jar and put it in the liquibase/lib directory.

    • Maven users only:

      Add this dependency to your pom.xml

      file: <dependency> <groupId>org.liquibase.ext</groupId> <artifactId>liquibase-checks</artifactId> <version>2.0.0</version> </dependency>

  • Java Development Kit 17+ (available for Open JDK and Oracle JDK)

  • Linux, macOS, or Windows operating system

Procedure

These steps describe how to create the Custom Policy Check. It does not exist by default in Liquibase Pro.

1

Add this code to your Checks Settings file:

collectionNameIsCamel Case Python Script
    # # #
    # # # This script checks
    for camelCase collection names during createCollection
    # # #
    # # # Notes:
        # # # 1. Only basic createCollection statements are supported

    # # #
    # # # Helpers come from Liquibase
    # # #
    import re
    import sys
    import liquibase_utilities

    def find_substring_indices(string_list, substring):
        ""
    "
    Finds the indices of list elements containing a specified substring.

    Args:
        string_list: A list of strings.
    substring: The substring to search
    for.

    Returns:
        A list of indices where the substring is found, or an empty list
    if not found.
    ""
    "
    return [index
        for index, string in enumerate(string_list) if substring in string.casefold()
    ]

    def is_camel_case(input_string):
        ""
    "
    Checks
    if a string is in camel
    case.

    A string is considered camel
    case if it:
        -Contains only letters(a - z, A - Z) and optionally numbers(0 - 9). -
        Contains both lowercase and uppercase letters. -
        Does not start with a number.

    Args:
        input_string: The string to check.

    Returns:
        True
    if the string is in camel
    case, False otherwise.
    ""
    "
    if not isinstance(input_string, str):
        return False

    if not re.match(r "^[a-zA-Z][a-zA-Z0-9]*$", input_string):
        return False

    if input_string[0].isdigit():
        return False

    if not any(char.islower() for char in input_string) or not any(char.isupper() for char in input_string):
        return False

    return True

    def extract_substring(text, start_char, end_char):
        ""
    "
    Extracts the substring between the first occurrence of start_char and end_char in text.

    Args:
        text: The string to search within.
    start_char: The character marking the beginning of the substring.
    end_char: The character marking the end of the substring.

    Returns:
        The extracted substring, or an empty string
    if start_char or end_char are not found,
    or
    if end_char appears before start_char.
    ""
    "
    try:
    start_index = text.index(start_char) + 1
    end_index = text.index(end_char, start_index)
    return text[start_index: end_index]
    except ValueError:
        return ""

    # # #
    # # # Retrieve log handler
    # # # Ex.liquibase_logger.info(message)
    # # #
    liquibase_logger = liquibase_utilities.get_logger()

    # # #
    # # # Retrieve status handler
    # # #
    liquibase_status = liquibase_utilities.get_status()

    # # #
    # # # Retrieve all changes in changeset
    # # #
    changes = liquibase_utilities.get_changeset().getChanges()

    # # #
    # # # Loop through all changes
    # # #
    for change in changes:
        # # #
    # # #
    # # # Split mongo code into a list of strings to remove whitespace
    # # #
    js_list = liquibase_utilities.generate_sql(change).split()
    # print(list(js_list))
    # # #
    # # # Locate createCollection in list
    # # #

    if any("createcollection" in element
            for element in map(str.casefold, js_list)):

        # # # Get all indexes consisting of "createCollection", irrelevant of
        case
    # # # Returns indices as list
    indices = find_substring_indices(js_list, "createcollection")

    for index in indices:
        collection = js_list[index]

    # # # Look
    for collection name in this format:
        # # # db.createCollection('collectionName');
    collectionName = extract_substring(collection, "'", "'")

    # # # Account
    for spaces like this:
        # # # db.createCollection('collectionName');
    if not collectionName:
        collectionName = extract_substring(js_list[index + 1], "'", "'")

    isCamelCase = is_camel_case(collectionName)
    print("index=" + str(index) + ", " + str(collection) + ", ", str(collectionName) + ", ", str(isCamelCase))

    if not isCamelCase:
        liquibase_status.fired = True
    status_message = "Collection name \"" + f "{collectionName}" + "\" is NOT camelCase."
    liquibase_status.message = status_message
    sys.exit(1)

    # # #
    # # # Default
    return code
    # # #
    False
2

Initiate the customization process

In the CLI, run this command:

liquibase checks customize --check-name=CustomCheckTemplate

The CLI prompts you to finish configuring your file. A message displays:

This check cannot be customized directly because one or more fields does not have a default value.

Liquibase will then create a copy of CustomCheckTemplate and initiate the customization workflow.

3

Give your check a short name so you can easily identify what Python script it is associated with

You may use up to 64 alpha-numeric characters only.

In this example we will name the check: collectionNameIsCamelCase

4

Set the Severity to return a code of 0-4 when triggered.

These severity codes allow you to determine if the job moves forward or stops when this check triggers. Learn more here: Use Policy Checks in Automation: Severity and Exit Code options: 'INFO'=0, 'MINOR'=1, 'MAJOR'=2, 'CRITICAL'=3, 'BLOCKER'=4

5

Set SCRIPT_DESCRIPTION

In this example, we will set the description to:
This script ensures collection names use camelCase.
6

Set the SCRIPT_SCOPE

In this example, we will set the scope to:

  • changelog: for example, if your check looks for syntax patterns or attributes in your Liquibase Changelog (the changes you author in your repository). With this value, the check runs once per changeset.

7

Set the SCRIPT_MESSAGE

This message will display when the check is triggered. In this example we will use:

Table name "myaccounts" is NOT camelCase. It is recommended you fix the casing before proceeding.

8

Set the SCRIPT_PATH

This is the relative path where your script is stored in relation to the changelog specified in --changelog-file, whether it is stored locally or in a repository.

In this example, we will set the path to: scripts/collection-camel-case.py

9

This check does not require a SCRIPT_ARGUMENT, so leave this blank.

10

Set the REQUIRES_SNAPSHOT

If your script scope is changelog, set whether the check requires a database snapshot. Specify true if your check needs to inspect database objects.

If your script scope is database, Liquibase always takes a snapshot, so this prompt does not appear.

Note: The larger your database, the more performance impact a snapshot causes. If you cannot run a snapshot due to memory limitations, see Memory Limits of Inspecting Large Schemas.