@documentation-robotics/cli 0.1.0

package/dist/schemas/bundled/08-datastore-layer.schema.json

@@ -0,0 +1,892 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/schemas/08-datastore-layer.schema.json",
+  "title": "Datastore Layer Layer Schema",
+  "description": "Defines physical data storage schemas using SQL DDL, including tables, columns, indexes, constraints, and database-specific objects.",
+  "layerMetadata": {
+    "layerId": "08-datastore-layer",
+    "layerName": "Datastore Layer",
+    "intraLayerRelationshipSupport": true,
+    "crossLayerRelationshipSupport": true,
+    "relationshipCatalogVersion": "2.1.0"
+  },
+  "intraLayerRelationships": {
+    "$comment": "Relationships between entities within this layer. References relationship-catalog.json by ID.",
+    "allowed": [
+      {
+        "relationshipTypeId": "composition",
+        "sourceTypes": ["Database", "DatabaseSchema", "Table"],
+        "targetTypes": ["Column", "Constraint", "DatabaseSchema", "Index", "Table"],
+        "examples": [
+          {
+            "source": "Database",
+            "target": "DatabaseSchema",
+            "description": "Database instance contains one or more schemas",
+            "layer": "08-datastore"
+          },
+          {
+            "source": "DatabaseSchema",
+            "target": "Table",
+            "description": "Schema contains tables as physical storage units",
+            "layer": "08-datastore"
+          },
+          {
+            "source": "Table",
+            "target": "Column",
+            "description": "Table is composed of columns defining its structure",
+            "layer": "08-datastore"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "aggregation",
+        "sourceTypes": ["Constraint", "Index"],
+        "targetTypes": ["Column"],
+        "examples": [
+          {
+            "source": "Index",
+            "target": "Column",
+            "description": "Index aggregates one or more columns (composite indexes)",
+            "layer": "08-datastore"
+          },
+          {
+            "source": "Constraint",
+            "target": "Column",
+            "description": "Constraint aggregates columns (composite keys, multi-column checks)",
+            "layer": "08-datastore"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "specialization",
+        "sourceTypes": ["PremiumAccount", "Schema"],
+        "targetTypes": ["Account", "Schema"],
+        "examples": [
+          {
+            "source": "PremiumAccount",
+            "target": "Account",
+            "description": "Premium account specializes the general account concept"
+          },
+          {
+            "source": "Schema",
+            "target": "Schema",
+            "description": "API schema specializes another via allOf/oneOf/anyOf composition",
+            "layer": "06-api"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "triggering",
+        "sourceTypes": ["Trigger"],
+        "targetTypes": ["Function"],
+        "examples": [
+          {
+            "source": "Trigger",
+            "target": "Function",
+            "description": "Database trigger executes specified function on event",
+            "layer": "08-datastore"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "serving",
+        "sourceTypes": ["BusinessService", "ContextVariation", "InputSpacePartition"],
+        "targetTypes": ["BusinessActor", "TestCoverageTarget"],
+        "examples": [
+          {
+            "source": "BusinessService",
+            "target": "BusinessActor",
+            "description": "Business service serves business actor"
+          },
+          {
+            "source": "InputSpacePartition",
+            "target": "TestCoverageTarget",
+            "description": "Partition serves target by defining testable input space",
+            "layer": "12-testing"
+          },
+          {
+            "source": "ContextVariation",
+            "target": "TestCoverageTarget",
+            "description": "Context serves target by defining execution environments",
+            "layer": "12-testing"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "access",
+        "sourceTypes": ["BusinessProcess", "CoverageRequirement", "TestCaseSketch"],
+        "targetTypes": ["BusinessObject", "InputPartitionSelection", "InputSelection"],
+        "examples": [
+          {
+            "source": "BusinessProcess",
+            "target": "BusinessObject",
+            "description": "Business process accesses business object data"
+          },
+          {
+            "source": "TestCaseSketch",
+            "target": "InputSelection",
+            "description": "Test sketch accesses input selections for test execution",
+            "layer": "12-testing"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "InputPartitionSelection",
+            "description": "Requirement accesses partition selections for coverage",
+            "layer": "12-testing"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "reference",
+        "sourceTypes": ["CoverageRequirement", "DataObject", "TestCaseSketch"],
+        "targetTypes": ["CoverageRequirement", "Schema", "TestCoverageTarget"],
+        "examples": [
+          {
+            "source": "DataObject",
+            "target": "Schema",
+            "description": "Data object references JSON schema"
+          },
+          {
+            "source": "TestCaseSketch",
+            "target": "CoverageRequirement",
+            "description": "Test case sketch references coverage requirement it satisfies",
+            "layer": "12-testing"
+          },
+          {
+            "source": "CoverageRequirement",
+            "target": "TestCoverageTarget",
+            "description": "Coverage requirement references target it covers",
+            "layer": "12-testing"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "depends-on",
+        "sourceTypes": ["ApplicationService", "TestCaseSketch"],
+        "targetTypes": ["ContextVariation", "DataObject", "OutcomeCategory"],
+        "examples": [
+          {
+            "source": "ApplicationService",
+            "target": "DataObject",
+            "description": "Application service depends on data object"
+          },
+          {
+            "source": "TestCaseSketch",
+            "target": "ContextVariation",
+            "description": "Test sketch depends on context for execution environment",
+            "layer": "12-testing"
+          },
+          {
+            "source": "TestCaseSketch",
+            "target": "OutcomeCategory",
+            "description": "Test sketch depends on expected outcome category",
+            "layer": "12-testing"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "maps-to",
+        "sourceTypes": ["DataObject"],
+        "targetTypes": ["DatabaseTable"],
+        "examples": [
+          {
+            "source": "DataObject",
+            "target": "DatabaseTable",
+            "description": "User data object maps to users table"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "references-table",
+        "sourceTypes": ["OrderTable"],
+        "targetTypes": ["CustomerTable"],
+        "examples": [
+          {
+            "source": "OrderTable",
+            "target": "CustomerTable",
+            "description": "Order table references customer table via foreign key"
+          }
+        ]
+      },
+      {
+        "relationshipTypeId": "derivedfrom",
+        "sourceTypes": ["TotalPrice"],
+        "targetTypes": ["Quantity, UnitPrice"],
+        "examples": [
+          {
+            "source": "TotalPrice",
+            "target": "Quantity, UnitPrice",
+            "description": "Total price derives from quantity times unit price"
+          }
+        ]
+      }
+    ]
+  },
+  "crossLayerRelationships": {
+    "$comment": "Relationships to/from entities in other layers",
+    "outgoing": [
+      {
+        "id": "motivation-governed-by-principles",
+        "predicate": "governed-by-principles",
+        "inversePredicate": "governs",
+        "targetLayer": "01-motivation",
+        "targetTypes": ["GovernedByPrinciple"],
+        "sourceTypes": ["BusinessService"],
+        "fieldPath": "motivation.governed-by-principles",
+        "cardinality": "array",
+        "format": "reference",
+        "strength": "high",
+        "required": false,
+        "description": "BusinessService governed by Principles",
+        "examples": [
+          {
+            "elementType": "BusinessService",
+            "elementId": "order-service",
+            "elementName": "Order Processing Service",
+            "fieldPath": "motivation.governed-by-principles",
+            "value": "principle-customer-first,principle-automation",
+            "layer": "02-business"
+          },
+          {
+            "elementType": "ApplicationService",
+            "elementId": "product-service",
+            "elementName": "product-service",
+            "fieldPath": "motivation.governed-by-principles",
+            "value": "principle-api-first,principle-cloud-native",
+            "layer": "04-application"
+          }
+        ]
+      },
+      {
+        "id": "motivation-supports-goals",
+        "predicate": "supports-goals",
+        "inversePredicate": "supported-by",
+        "targetLayer": "01-motivation",
+        "targetTypes": ["SupportsGoal"],
+        "sourceTypes": ["BusinessService"],
+        "fieldPath": "motivation.supports-goals",
+        "cardinality": "array",
+        "format": "reference",
+        "strength": "high",
+        "required": false,
+        "description": "BusinessService supports Goals",
+        "examples": [
+          {
+            "elementType": "BusinessService",
+            "elementId": "order-service",
+            "elementName": "Order Processing Service",
+            "fieldPath": "motivation.supports-goals",
+            "value": "goal-customer-satisfaction,goal-revenue-growth",
+            "layer": "02-business"
+          },
+          {
+            "elementType": "ApplicationService",
+            "elementId": "product-service",
+            "elementName": "product-service",
+            "fieldPath": "motivation.supports-goals",
+            "value": "goal-product-catalog-accuracy,goal-customer-satisfaction",
+            "layer": "04-application"
+          }
+        ]
+      },
+      {
+        "id": "security-classification",
+        "predicate": "classification",
+        "inversePredicate": "referenced-by",
+        "targetLayer": "03-security",
+        "targetTypes": ["Classification"],
+        "sourceTypes": ["Artifact"],
+        "fieldPath": "security.classification",
+        "cardinality": "single",
+        "format": "string",
+        "strength": "low",
+        "required": false,
+        "description": "Links to Classification in target layer",
+        "examples": [
+          {
+            "elementType": "Artifact",
+            "elementId": "product-db",
+            "elementName": "product-db",
+            "fieldPath": "security.classification",
+            "value": "internal",
+            "layer": "05-technology"
+          },
+          {
+            "elementType": "Artifact",
+            "elementId": "customer-db",
+            "elementName": "customer-db",
+            "fieldPath": "security.classification",
+            "value": "restricted",
+            "layer": "05-technology"
+          }
+        ]
+      }
+    ],
+    "incoming": []
+  },
+  "type": "object",
+  "properties": {
+    "databases": {
+      "type": "array",
+      "description": "Collection of Database entities",
+      "items": {
+        "$ref": "#/definitions/Database"
+      }
+    },
+    "database-schemas": {
+      "type": "array",
+      "description": "Collection of DatabaseSchema entities",
+      "items": {
+        "$ref": "#/definitions/DatabaseSchema"
+      }
+    },
+    "tables": {
+      "type": "array",
+      "description": "Collection of Table entities",
+      "items": {
+        "$ref": "#/definitions/Table"
+      }
+    },
+    "columns": {
+      "type": "array",
+      "description": "Collection of Column entities",
+      "items": {
+        "$ref": "#/definitions/Column"
+      }
+    },
+    "constraints": {
+      "type": "array",
+      "description": "Collection of Constraint entities",
+      "items": {
+        "$ref": "#/definitions/Constraint"
+      }
+    },
+    "indexes": {
+      "type": "array",
+      "description": "Collection of Index entities",
+      "items": {
+        "$ref": "#/definitions/Index"
+      }
+    },
+    "views": {
+      "type": "array",
+      "description": "Collection of View entities",
+      "items": {
+        "$ref": "#/definitions/View"
+      }
+    },
+    "triggers": {
+      "type": "array",
+      "description": "Collection of Trigger entities",
+      "items": {
+        "$ref": "#/definitions/Trigger"
+      }
+    },
+    "sequences": {
+      "type": "array",
+      "description": "Collection of Sequence entities",
+      "items": {
+        "$ref": "#/definitions/Sequence"
+      }
+    },
+    "functions": {
+      "type": "array",
+      "description": "Collection of Function entities",
+      "items": {
+        "$ref": "#/definitions/Function"
+      }
+    }
+  },
+  "definitions": {
+    "DatabaseType": {
+      "type": "string",
+      "enum": ["PostgreSQL", "MySQL", "SQLite", "MariaDB", "Oracle", "SQL Server"]
+    },
+    "SQLDataType": {
+      "type": "string",
+      "enum": [
+        "SMALLINT",
+        "INTEGER",
+        "BIGINT",
+        "SERIAL",
+        "BIGSERIAL",
+        "DECIMAL(precision, scale)",
+        "NUMERIC(precision, scale)",
+        "REAL",
+        "DOUBLE PRECISION",
+        "CHAR(length)",
+        "VARCHAR(length)",
+        "TEXT",
+        "BYTEA",
+        "BLOB",
+        "BOOLEAN",
+        "DATE",
+        "TIME",
+        "TIMESTAMP",
+        "TIMESTAMPTZ",
+        "INTERVAL",
+        "JSON",
+        "JSONB",
+        "UUID",
+        "INTEGER[]",
+        "TEXT[]",
+        "etc.",
+        "ENUM('value1', 'value2', ...)"
+      ]
+    },
+    "GenerationType": {
+      "type": "string",
+      "enum": ["ALWAYS", "BY_DEFAULT"]
+    },
+    "ConstraintType": {
+      "type": "string",
+      "enum": ["PRIMARY_KEY", "UNIQUE", "FOREIGN_KEY", "CHECK", "EXCLUSION"]
+    },
+    "ReferentialAction": {
+      "type": "string",
+      "enum": ["CASCADE", "SET_NULL", "SET_DEFAULT", "RESTRICT", "NO_ACTION"]
+    },
+    "IndexMethod": {
+      "type": "string",
+      "enum": ["BTREE", "HASH", "GIN", "GIST", "BRIN", "SP-GIST"]
+    },
+    "RefreshMode": {
+      "type": "string",
+      "enum": ["ON_COMMIT", "ON_DEMAND", "SCHEDULED"]
+    },
+    "TriggerTiming": {
+      "type": "string",
+      "enum": ["BEFORE", "AFTER", "INSTEAD_OF"]
+    },
+    "TriggerEvent": {
+      "type": "string",
+      "enum": ["INSERT", "UPDATE", "DELETE", "TRUNCATE"]
+    },
+    "TriggerForEach": {
+      "type": "string",
+      "enum": ["ROW", "STATEMENT"]
+    },
+    "SequenceDataType": {
+      "type": "string",
+      "enum": ["SMALLINT", "INTEGER", "BIGINT"]
+    },
+    "FunctionLanguage": {
+      "type": "string",
+      "enum": ["SQL", "PLPGSQL", "PLPYTHON3U", "PLPERL", "PLPYTHON", "C"]
+    },
+    "FunctionVolatility": {
+      "type": "string",
+      "enum": ["IMMUTABLE", "STABLE", "VOLATILE"]
+    },
+    "ParallelSafety": {
+      "type": "string",
+      "enum": ["UNSAFE", "RESTRICTED", "SAFE"]
+    },
+    "SecurityDefiner": {
+      "type": "string",
+      "enum": ["INVOKER", "DEFINER"]
+    },
+    "ParameterMode": {
+      "type": "string",
+      "enum": ["IN", "OUT", "INOUT", "VARIADIC"]
+    },
+    "Database": {
+      "type": "object",
+      "description": "Database instance containing schemas",
+      "required": ["id", "name", "type", "version"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "type": {
+          "$ref": "#/definitions/DatabaseType"
+        },
+        "version": {
+          "type": "string",
+          "minLength": 1
+        },
+        "charset": {
+          "type": "string",
+          "minLength": 1
+        },
+        "collation": {
+          "type": "string",
+          "minLength": 1
+        },
+        "schemas": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "DatabaseSchema": {
+      "type": "object",
+      "description": "Logical grouping of database objects",
+      "required": ["id", "name"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "owner": {
+          "type": "string",
+          "minLength": 1
+        },
+        "tables": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "views": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "functions": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "sequences": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "Table": {
+      "type": "object",
+      "description": "Database table definition",
+      "required": ["id", "name"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "schema": {
+          "type": "string",
+          "minLength": 1
+        },
+        "tablespace": {
+          "type": "string",
+          "minLength": 1
+        },
+        "columns": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "constraints": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "indexes": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "triggers": {
+          "type": "array",
+          "description": "Contains relationship",
+          "items": {
+            "type": "string"
+          }
+        },
+        "x-source-reference": {
+          "$ref": "common/source-references.schema.json#/definitions/SourceReference",
+          "description": "Source code reference using OpenAPI x- extension pattern. This pattern is used for OpenAPI-style layers (API, Data Model, Datastore) to maintain compatibility with OpenAPI tooling, as opposed to the nested properties.source.reference pattern used in ArchiMate-style layers (Application, Technology)."
+        }
+      }
+    },
+    "Column": {
+      "type": "object",
+      "description": "Table column definition",
+      "required": ["id", "name", "dataType"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "dataType": {
+          "type": "string",
+          "minLength": 1
+        },
+        "nullable": {
+          "type": "boolean"
+        },
+        "defaultValue": {
+          "type": "string",
+          "minLength": 1
+        },
+        "generated": {
+          "type": "string",
+          "minLength": 1
+        },
+        "x-source-reference": {
+          "$ref": "common/source-references.schema.json#/definitions/SourceReference",
+          "description": "Source code reference using OpenAPI x- extension pattern. This pattern is used for OpenAPI-style layers (API, Data Model, Datastore) to maintain compatibility with OpenAPI tooling, as opposed to the nested properties.source.reference pattern used in ArchiMate-style layers (Application, Technology)."
+        }
+      }
+    },
+    "Constraint": {
+      "type": "object",
+      "description": "Table constraint",
+      "required": ["id", "name", "type"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "type": {
+          "$ref": "#/definitions/ConstraintType"
+        }
+      }
+    },
+    "Index": {
+      "type": "object",
+      "description": "Database index for query optimization",
+      "required": ["id", "name"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "columns": {
+          "type": "string",
+          "minLength": 1
+        },
+        "unique": {
+          "type": "boolean"
+        },
+        "method": {
+          "type": "string",
+          "minLength": 1
+        },
+        "where": {
+          "type": "string",
+          "minLength": 1
+        },
+        "include": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "View": {
+      "type": "object",
+      "description": "Database view",
+      "required": ["id", "name"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "definition": {
+          "type": "string",
+          "minLength": 1
+        },
+        "materialized": {
+          "type": "boolean"
+        }
+      }
+    },
+    "Trigger": {
+      "type": "object",
+      "description": "A database trigger that automatically executes in response to data modification events (INSERT, UPDATE, DELETE). Enables reactive database behavior and data integrity enforcement.",
+      "required": [
+        "id",
+        "name",
+        "table",
+        "timing",
+        "events",
+        "forEach",
+        "functionName",
+        "condition"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "table": {
+          "type": "string",
+          "minLength": 1
+        },
+        "timing": {
+          "$ref": "#/definitions/TriggerTiming"
+        },
+        "events": {
+          "type": "string",
+          "minLength": 1
+        },
+        "forEach": {
+          "$ref": "#/definitions/TriggerForEach"
+        },
+        "functionName": {
+          "type": "string",
+          "minLength": 1
+        },
+        "condition": {
+          "type": "string",
+          "minLength": 1
+        },
+        "enabled": {
+          "type": "boolean"
+        }
+      }
+    },
+    "Sequence": {
+      "type": "object",
+      "description": "A database sequence generator that produces unique, ordered numeric values. Used for generating primary keys, order numbers, or other sequential identifiers.",
+      "required": ["id", "name"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "schema": {
+          "type": "string",
+          "minLength": 1
+        },
+        "dataType": {
+          "$ref": "#/definitions/SequenceDataType"
+        },
+        "startValue": {
+          "type": "integer"
+        },
+        "increment": {
+          "type": "integer"
+        },
+        "minValue": {
+          "type": "integer"
+        },
+        "maxValue": {
+          "type": "integer"
+        },
+        "cycle": {
+          "type": "boolean"
+        },
+        "cache": {
+          "type": "integer"
+        },
+        "ownedBy": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "Function": {
+      "type": "object",
+      "description": "A stored database function that encapsulates reusable computation logic. Returns a value and can be used in SQL expressions for data transformation or validation.",
+      "required": ["id", "name", "language", "returnType"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid",
+          "minLength": 1
+        },
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "schema": {
+          "type": "string",
+          "minLength": 1
+        },
+        "language": {
+          "$ref": "#/definitions/FunctionLanguage"
+        },
+        "returnType": {
+          "type": "string",
+          "minLength": 1
+        },
+        "volatility": {
+          "$ref": "#/definitions/FunctionVolatility"
+        },
+        "parallel": {
+          "$ref": "#/definitions/ParallelSafety"
+        },
+        "strict": {
+          "type": "boolean"
+        },
+        "security": {
+          "$ref": "#/definitions/SecurityDefiner"
+        },
+        "cost": {
+          "type": "integer"
+        },
+        "rows": {
+          "type": "integer"
+        },
+        "x-source-reference": {
+          "$ref": "common/source-references.schema.json#/definitions/SourceReference",
+          "description": "Source code reference using OpenAPI x- extension pattern. This pattern is used for OpenAPI-style layers (API, Data Model, Datastore) to maintain compatibility with OpenAPI tooling, as opposed to the nested properties.source.reference pattern used in ArchiMate-style layers (Application, Technology)."
+        }
+      }
+    }
+  }
+}