@documentation-robotics/cli 0.1.0 → 0.1.5

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

@@ -1,892 +0,0 @@
-{
-  "$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)."
-        }
-      }
-    }
-  }
-}