@soddong/agentic-domain-artifact-standard 0.11.0

package/dist/repositories.js

@@ -0,0 +1,730 @@
+import { isValidationExecutionModeCode, isValidationSeverityCode, isValidationTypeCode } from "@soddong/agentic-contract-validation";
+function jsonValue(value) {
+    return value === undefined || value === null ? null : JSON.stringify(value);
+}
+function parseJson(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        return undefined;
+    }
+    return JSON.parse(value);
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function optionalNumber(value) {
+    return typeof value === "number" ? value : undefined;
+}
+function boolToInt(value, defaultValue) {
+    return value === undefined ? defaultValue : value ? 1 : 0;
+}
+function standardFromRow(row) {
+    return {
+        artifactStandardId: row.artifact_standard_id,
+        artifactStandardCode: row.artifact_standard_code,
+        artifactStandardVersion: row.artifact_standard_version,
+        artifactStandardName: row.artifact_standard_name,
+        standardTypeCode: row.standard_type_code,
+        standardStatusCode: row.standard_status_code,
+        purpose: optionalString(row.purpose),
+        description: optionalString(row.description),
+        ownerRoleCode: optionalString(row.owner_role_code),
+        isActive: row.is_active,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function componentFromRow(row) {
+    return {
+        componentId: row.component_id,
+        artifactStandardId: row.artifact_standard_id,
+        componentCode: row.component_code,
+        componentTypeCode: row.component_type_code,
+        componentTitle: row.component_title,
+        componentPurpose: optionalString(row.component_purpose),
+        applicabilityCode: row.applicability_code,
+        resourceRefTypeCode: row.resource_ref_type_code,
+        resourceRef: optionalString(row.resource_ref),
+        sortOrder: row.sort_order,
+        isActive: row.is_active,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function componentBindingFromRow(row) {
+    return {
+        componentBindingId: row.component_binding_id,
+        artifactStandardId: row.artifact_standard_id,
+        componentId: row.component_id,
+        targetTypeCode: row.target_type_code,
+        targetRef: row.target_ref,
+        bindingRoleCode: row.binding_role_code,
+        priority: row.priority,
+        appliesWhen: parseJson(row.applies_when_json),
+        description: optionalString(row.description),
+        isActive: row.is_active,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function blueprintFromRow(row) {
+    return {
+        blueprintId: row.blueprint_id,
+        artifactStandardId: row.artifact_standard_id,
+        blueprintCode: row.blueprint_code,
+        blueprintName: row.blueprint_name,
+        documentTypeCode: row.document_type_code,
+        taxonomyCode: optionalString(row.taxonomy_code),
+        defaultTocLevelLimit: row.default_toc_level_limit,
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function blueprintNodeFromRow(row) {
+    return {
+        blueprintNodeId: row.blueprint_node_id,
+        blueprintId: row.blueprint_id,
+        parentBlueprintNodeId: optionalString(row.parent_blueprint_node_id),
+        nodeCode: row.node_code,
+        nodeTitle: row.node_title,
+        nodeTypeCode: row.node_type_code,
+        nodeLevel: row.node_level,
+        tocVisible: row.toc_visible,
+        isRequired: row.is_required,
+        isRepeatable: row.is_repeatable,
+        repeatContextCode: optionalString(row.repeat_context_code),
+        taxonomyRef: optionalString(row.taxonomy_ref),
+        description: optionalString(row.description),
+        sortOrder: row.sort_order,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function slotFromRow(row) {
+    return {
+        templateSlotId: row.template_slot_id,
+        blueprintId: row.blueprint_id,
+        blueprintNodeId: optionalString(row.blueprint_node_id),
+        parentTemplateSlotId: optionalString(row.parent_template_slot_id),
+        slotCode: row.slot_code,
+        slotName: row.slot_name,
+        slotTypeCode: row.slot_type_code,
+        blockTypeCode: optionalString(row.block_type_code),
+        isRequired: row.is_required,
+        isRepeatable: row.is_repeatable,
+        repeatContextCode: optionalString(row.repeat_context_code),
+        schemaRef: optionalString(row.schema_ref),
+        description: optionalString(row.description),
+        sortOrder: row.sort_order,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function documentComponentFromRow(row) {
+    return {
+        documentComponentId: row.document_component_id,
+        artifactStandardId: row.artifact_standard_id,
+        blueprintId: optionalString(row.blueprint_id),
+        parentDocumentComponentId: optionalString(row.parent_document_component_id),
+        documentComponentCode: row.document_component_code,
+        documentComponentName: row.document_component_name,
+        componentRoleCode: row.component_role_code,
+        componentTypeCode: row.component_type_code,
+        representationCode: row.representation_code,
+        logicalLevel: row.logical_level,
+        isRequired: row.is_required,
+        isRepeatable: row.is_repeatable,
+        sortOrder: row.sort_order,
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function documentComponentRelationFromRow(row) {
+    return {
+        documentComponentRelationId: row.document_component_relation_id,
+        artifactStandardId: row.artifact_standard_id,
+        sourceDocumentComponentId: row.source_document_component_id,
+        targetDocumentComponentId: row.target_document_component_id,
+        relationTypeCode: row.relation_type_code,
+        isRequired: row.is_required,
+        sortOrder: row.sort_order,
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function physicalStructurePolicyFromRow(row) {
+    return {
+        physicalStructurePolicyId: row.physical_structure_policy_id,
+        artifactStandardId: row.artifact_standard_id,
+        documentComponentId: optionalString(row.document_component_id),
+        policyCode: row.policy_code,
+        policyName: row.policy_name,
+        strategyCode: row.strategy_code,
+        relationSourceCode: row.relation_source_code,
+        pathPattern: optionalString(row.path_pattern),
+        namingPattern: optionalString(row.naming_pattern),
+        isDefault: row.is_default,
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function tableSchemaFromRow(row) {
+    return {
+        tableSchemaId: row.table_schema_id,
+        artifactStandardId: row.artifact_standard_id,
+        tableSchemaCode: row.table_schema_code,
+        tableName: row.table_name,
+        captionRequired: row.caption_required,
+        rowsRequired: row.rows_required,
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function tableColumnFromRow(row) {
+    return {
+        tableColumnSchemaId: row.table_column_schema_id,
+        tableSchemaId: row.table_schema_id,
+        columnCode: row.column_code,
+        displayName: row.display_name,
+        valueTypeCode: row.value_type_code,
+        isRequired: row.is_required,
+        isNullable: row.is_nullable,
+        sortOrder: row.sort_order,
+        codeSetRef: optionalString(row.code_set_ref),
+        allowedValuesRef: optionalString(row.allowed_values_ref),
+        validationRuleRef: optionalString(row.validation_rule_ref),
+        pattern: optionalString(row.pattern),
+        minValue: optionalNumber(row.min_value),
+        maxValue: optionalNumber(row.max_value),
+        minLength: optionalNumber(row.min_length),
+        maxLength: optionalNumber(row.max_length),
+        exampleValue: optionalString(row.example_value),
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function ruleSetFromRow(row) {
+    return {
+        validationRuleSetId: row.validation_rule_set_id,
+        artifactStandardId: row.artifact_standard_id,
+        ruleSetCode: row.rule_set_code,
+        ruleSetName: row.rule_set_name,
+        targetDomain: row.target_domain,
+        description: optionalString(row.description),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function ruleSetRuleFromRow(row) {
+    return {
+        validationRuleSetRuleId: row.validation_rule_set_rule_id,
+        validationRuleSetId: row.validation_rule_set_id,
+        ruleId: row.rule_id,
+        validationTypeCode: row.validation_type_code,
+        executionModeCode: row.execution_mode_code,
+        severityCode: row.severity_code,
+        appliesToTypeCode: row.applies_to_type_code,
+        appliesToRef: optionalString(row.applies_to_ref),
+        sourceComponentRef: optionalString(row.source_component_ref),
+        parameters: parseJson(row.parameters_json),
+        message: row.message,
+        remediation: optionalString(row.remediation),
+        sortOrder: row.sort_order,
+        isActive: row.is_active,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function generatedOutputLinkFromRow(row) {
+    return {
+        generatedOutputLinkId: row.generated_output_link_id,
+        linkCode: row.link_code,
+        sourceArtifactStandardId: row.source_artifact_standard_id,
+        sourceArtifactStandardCode: row.source_artifact_standard_code,
+        sourceArtifactStandardVersion: row.source_artifact_standard_version,
+        targetTypeCode: row.target_type_code,
+        targetArtifactStandardId: optionalString(row.target_artifact_standard_id),
+        targetArtifactStandardCode: optionalString(row.target_artifact_standard_code),
+        targetArtifactStandardVersion: optionalString(row.target_artifact_standard_version),
+        targetOutputName: optionalString(row.target_output_name),
+        generationModeCode: row.generation_mode_code,
+        sortOrder: row.sort_order,
+        description: optionalString(row.description),
+        isActive: row.is_active,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function sourceMappingFromRow(row) {
+    return {
+        sourceMappingId: row.source_mapping_id,
+        artifactStandardId: row.artifact_standard_id,
+        sourceTypeCode: row.source_type_code,
+        sourceUri: row.source_uri,
+        sourceLabel: optionalString(row.source_label),
+        sourceSection: optionalString(row.source_section),
+        sourceFragment: optionalString(row.source_fragment),
+        targetTypeCode: row.target_type_code,
+        targetRef: row.target_ref,
+        mappingTypeCode: row.mapping_type_code,
+        mappingStatusCode: row.mapping_status_code,
+        rationale: optionalString(row.rationale),
+        lossNote: optionalString(row.loss_note),
+        followUpNote: optionalString(row.follow_up_note),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        metadata: parseJson(row.metadata_json)
+    };
+}
+function validationRuleContractFromRecord(rule) {
+    return {
+        ruleId: rule.ruleId,
+        providerModule: "@soddong/agentic-domain-artifact-standard",
+        validationTypeCode: rule.validationTypeCode,
+        executionModeCode: rule.executionModeCode,
+        severityCode: rule.severityCode,
+        appliesToTypeCode: rule.appliesToTypeCode,
+        appliesToRef: rule.appliesToRef,
+        sourceComponentRef: rule.sourceComponentRef,
+        parameters: rule.parameters,
+        message: rule.message,
+        remediation: rule.remediation,
+        metadata: rule.metadata
+    };
+}
+const artifactStandardValidationTargetTypeCodes = new Set([
+    "ARTIFACT_STANDARD",
+    "DOCUMENT_BLUEPRINT",
+    "BLUEPRINT_NODE",
+    "TEMPLATE_SLOT",
+    "TABLE_SCHEMA",
+    "TABLE_COLUMN_SCHEMA",
+    "FIGURE_POLICY",
+    "DIAGRAM_POLICY",
+    "COMPONENT",
+    "COMPONENT_BINDING",
+    "VALIDATION_RULE_SET",
+    "DOCUMENT_COMPONENT",
+    "DOCUMENT_COMPONENT_RELATION",
+    "PHYSICAL_STRUCTURE_POLICY"
+]);
+export class ArtifactStandardRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createArtifactStandard(artifactStandardId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_standards
+           (artifact_standard_id, artifact_standard_code, artifact_standard_version, artifact_standard_name,
+            standard_type_code, standard_status_code, purpose, description, owner_role_code, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(artifactStandardId, input.artifactStandardCode, input.artifactStandardVersion, input.artifactStandardName, input.standardTypeCode ?? "DOCUMENT", input.standardStatusCode ?? "DRAFT", input.purpose ?? null, input.description ?? null, input.ownerRoleCode ?? null, jsonValue(input.metadata));
+        return this.getArtifactStandardById(artifactStandardId);
+    }
+    getArtifactStandardById(artifactStandardId) {
+        const row = this.db
+            .prepare(`SELECT * FROM artifact_standard_standards WHERE artifact_standard_id = ?`)
+            .get(artifactStandardId);
+        if (row === undefined) {
+            throw new Error(`Artifact standard not found: ${artifactStandardId}`);
+        }
+        return standardFromRow(row);
+    }
+    getArtifactStandardByCodeVersion(artifactStandardCode, artifactStandardVersion) {
+        const row = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_standards
+          WHERE artifact_standard_code = ?
+            AND artifact_standard_version = ?`)
+            .get(artifactStandardCode, artifactStandardVersion);
+        return row === undefined ? undefined : standardFromRow(row);
+    }
+    getArtifactStandardAggregateByCodeVersion(artifactStandardCode, artifactStandardVersion) {
+        const standard = this.getArtifactStandardByCodeVersion(artifactStandardCode, artifactStandardVersion);
+        if (standard === undefined) {
+            return undefined;
+        }
+        return this.getArtifactStandardAggregateById(standard.artifactStandardId);
+    }
+    getArtifactStandardAggregateById(artifactStandardId) {
+        const standard = this.getArtifactStandardById(artifactStandardId);
+        const blueprints = this.listDocumentBlueprints(artifactStandardId).map((blueprint) => ({
+            blueprint,
+            blueprintNodes: this.listBlueprintNodes(blueprint.blueprintId),
+            templateSlots: this.listTemplateSlots(blueprint.blueprintId)
+        }));
+        const tableSchemas = this.listTableSchemas(artifactStandardId).map((tableSchema) => ({
+            tableSchema,
+            columns: this.listTableColumnSchemas(tableSchema.tableSchemaId)
+        }));
+        const validationRuleSets = this.listValidationRuleSets(artifactStandardId).map((ruleSet) => ({
+            ruleSet,
+            rules: this.listValidationRuleSetRules(ruleSet.validationRuleSetId)
+        }));
+        return {
+            standard,
+            components: this.listComponents(artifactStandardId),
+            componentBindings: this.listComponentBindings(artifactStandardId),
+            blueprints,
+            documentComponents: this.listDocumentComponents(artifactStandardId),
+            documentComponentRelations: this.listDocumentComponentRelations(artifactStandardId),
+            physicalStructurePolicies: this.listPhysicalStructurePolicies(artifactStandardId),
+            tableSchemas,
+            validationRuleSets,
+            generatedOutputLinks: this.listGeneratedOutputLinksBySource(artifactStandardId),
+            sourceMappings: this.listSourceMappings(artifactStandardId)
+        };
+    }
+    addComponent(componentId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_components
+           (component_id, artifact_standard_id, component_code, component_type_code, component_title,
+            component_purpose, applicability_code, resource_ref_type_code, resource_ref, sort_order, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(componentId, input.artifactStandardId, input.componentCode, input.componentTypeCode, input.componentTitle, input.componentPurpose ?? null, input.applicabilityCode ?? "COMMON_REFERENCE", input.resourceRefTypeCode ?? "FILE_PATH", input.resourceRef ?? null, input.sortOrder ?? 0, jsonValue(input.metadata));
+        return componentFromRow(this.getById("artifact_standard_components", "component_id", componentId));
+    }
+    listComponents(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_components
+          WHERE artifact_standard_id = ?
+          ORDER BY sort_order, component_code`)
+            .all(artifactStandardId);
+        return rows.map(componentFromRow);
+    }
+    addComponentBinding(componentBindingId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_component_bindings
+           (component_binding_id, artifact_standard_id, component_id, target_type_code, target_ref,
+            binding_role_code, priority, applies_when_json, description, is_active, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(componentBindingId, input.artifactStandardId, input.componentId, input.targetTypeCode, input.targetRef, input.bindingRoleCode, input.priority ?? 100, jsonValue(input.appliesWhen), input.description ?? null, boolToInt(input.isActive, 1), jsonValue(input.metadata));
+        return componentBindingFromRow(this.getById("artifact_standard_component_bindings", "component_binding_id", componentBindingId));
+    }
+    listComponentBindings(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_component_bindings
+          WHERE artifact_standard_id = ?
+          ORDER BY priority, target_type_code, target_ref, binding_role_code`)
+            .all(artifactStandardId);
+        return rows.map(componentBindingFromRow);
+    }
+    listComponentBindingsByTarget(artifactStandardId, targetTypeCode, targetRef) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_component_bindings
+          WHERE artifact_standard_id = ?
+            AND target_type_code = ?
+            AND target_ref = ?
+            AND is_active = 1
+          ORDER BY priority, binding_role_code`)
+            .all(artifactStandardId, targetTypeCode, targetRef);
+        return rows.map(componentBindingFromRow);
+    }
+    addDocumentBlueprint(blueprintId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_document_blueprints
+           (blueprint_id, artifact_standard_id, blueprint_code, blueprint_name, document_type_code,
+            taxonomy_code, default_toc_level_limit, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(blueprintId, input.artifactStandardId, input.blueprintCode, input.blueprintName, input.documentTypeCode, input.taxonomyCode ?? null, input.defaultTocLevelLimit ?? 3, input.description ?? null, jsonValue(input.metadata));
+        return blueprintFromRow(this.getById("artifact_standard_document_blueprints", "blueprint_id", blueprintId));
+    }
+    listDocumentBlueprints(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_document_blueprints
+          WHERE artifact_standard_id = ?
+          ORDER BY blueprint_code`)
+            .all(artifactStandardId);
+        return rows.map(blueprintFromRow);
+    }
+    addBlueprintNode(blueprintNodeId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_blueprint_nodes
+           (blueprint_node_id, blueprint_id, parent_blueprint_node_id, node_code, node_title, node_type_code,
+            node_level, toc_visible, is_required, is_repeatable, repeat_context_code, taxonomy_ref,
+            description, sort_order, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(blueprintNodeId, input.blueprintId, input.parentBlueprintNodeId ?? null, input.nodeCode, input.nodeTitle, input.nodeTypeCode ?? "BODY", input.nodeLevel ?? 1, boolToInt(input.tocVisible, 1), boolToInt(input.isRequired, 1), boolToInt(input.isRepeatable, 0), input.repeatContextCode ?? null, input.taxonomyRef ?? null, input.description ?? null, input.sortOrder ?? 0, jsonValue(input.metadata));
+        return blueprintNodeFromRow(this.getById("artifact_standard_blueprint_nodes", "blueprint_node_id", blueprintNodeId));
+    }
+    listBlueprintNodes(blueprintId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_blueprint_nodes
+          WHERE blueprint_id = ?
+          ORDER BY sort_order, node_code`)
+            .all(blueprintId);
+        return rows.map(blueprintNodeFromRow);
+    }
+    addTemplateSlot(templateSlotId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_template_slots
+           (template_slot_id, blueprint_id, blueprint_node_id, parent_template_slot_id, slot_code, slot_name, slot_type_code,
+            block_type_code, is_required, is_repeatable, repeat_context_code, schema_ref, description, sort_order, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(templateSlotId, input.blueprintId, input.blueprintNodeId ?? null, input.parentTemplateSlotId ?? null, input.slotCode, input.slotName, input.slotTypeCode, input.blockTypeCode ?? null, boolToInt(input.isRequired, 1), boolToInt(input.isRepeatable, 0), input.repeatContextCode ?? null, input.schemaRef ?? null, input.description ?? null, input.sortOrder ?? 0, jsonValue(input.metadata));
+        return slotFromRow(this.getById("artifact_standard_template_slots", "template_slot_id", templateSlotId));
+    }
+    listTemplateSlots(blueprintId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_template_slots
+          WHERE blueprint_id = ?
+          ORDER BY sort_order, slot_code`)
+            .all(blueprintId);
+        return rows.map(slotFromRow);
+    }
+    addDocumentComponent(documentComponentId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_document_components
+           (document_component_id, artifact_standard_id, blueprint_id, parent_document_component_id,
+            document_component_code, document_component_name, component_role_code, component_type_code,
+            representation_code, logical_level, is_required, is_repeatable, sort_order, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(documentComponentId, input.artifactStandardId, input.blueprintId ?? null, input.parentDocumentComponentId ?? null, input.documentComponentCode, input.documentComponentName, input.componentRoleCode ?? "MAIN", input.componentTypeCode, input.representationCode ?? "SEPARATE_DOCUMENT", input.logicalLevel ?? 0, boolToInt(input.isRequired, 1), boolToInt(input.isRepeatable, 0), input.sortOrder ?? 0, input.description ?? null, jsonValue(input.metadata));
+        return documentComponentFromRow(this.getById("artifact_standard_document_components", "document_component_id", documentComponentId));
+    }
+    listDocumentComponents(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_document_components
+          WHERE artifact_standard_id = ?
+          ORDER BY logical_level, sort_order, document_component_code`)
+            .all(artifactStandardId);
+        return rows.map(documentComponentFromRow);
+    }
+    addDocumentComponentRelation(documentComponentRelationId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_document_component_relations
+           (document_component_relation_id, artifact_standard_id, source_document_component_id,
+            target_document_component_id, relation_type_code, is_required, sort_order, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(documentComponentRelationId, input.artifactStandardId, input.sourceDocumentComponentId, input.targetDocumentComponentId, input.relationTypeCode, boolToInt(input.isRequired, 0), input.sortOrder ?? 0, input.description ?? null, jsonValue(input.metadata));
+        return documentComponentRelationFromRow(this.getById("artifact_standard_document_component_relations", "document_component_relation_id", documentComponentRelationId));
+    }
+    listDocumentComponentRelations(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_document_component_relations
+          WHERE artifact_standard_id = ?
+          ORDER BY sort_order, relation_type_code, document_component_relation_id`)
+            .all(artifactStandardId);
+        return rows.map(documentComponentRelationFromRow);
+    }
+    addPhysicalStructurePolicy(physicalStructurePolicyId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_physical_structure_policies
+           (physical_structure_policy_id, artifact_standard_id, document_component_id, policy_code, policy_name,
+            strategy_code, relation_source_code, path_pattern, naming_pattern, is_default, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(physicalStructurePolicyId, input.artifactStandardId, input.documentComponentId ?? null, input.policyCode, input.policyName, input.strategyCode, input.relationSourceCode ?? "DB", input.pathPattern ?? null, input.namingPattern ?? null, boolToInt(input.isDefault, 0), input.description ?? null, jsonValue(input.metadata));
+        return physicalStructurePolicyFromRow(this.getById("artifact_standard_physical_structure_policies", "physical_structure_policy_id", physicalStructurePolicyId));
+    }
+    listPhysicalStructurePolicies(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_physical_structure_policies
+          WHERE artifact_standard_id = ?
+          ORDER BY is_default DESC, policy_code`)
+            .all(artifactStandardId);
+        return rows.map(physicalStructurePolicyFromRow);
+    }
+    addTableSchema(tableSchemaId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_table_schemas
+           (table_schema_id, artifact_standard_id, table_schema_code, table_name,
+            caption_required, rows_required, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(tableSchemaId, input.artifactStandardId, input.tableSchemaCode, input.tableName, boolToInt(input.captionRequired, 1), boolToInt(input.rowsRequired, 0), input.description ?? null, jsonValue(input.metadata));
+        return tableSchemaFromRow(this.getById("artifact_standard_table_schemas", "table_schema_id", tableSchemaId));
+    }
+    listTableSchemas(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_table_schemas
+          WHERE artifact_standard_id = ?
+          ORDER BY table_schema_code`)
+            .all(artifactStandardId);
+        return rows.map(tableSchemaFromRow);
+    }
+    addTableColumnSchema(tableColumnSchemaId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_table_column_schemas
+           (table_column_schema_id, table_schema_id, column_code, display_name, value_type_code,
+            is_required, is_nullable, sort_order, code_set_ref, allowed_values_ref, validation_rule_ref,
+            pattern, min_value, max_value, min_length, max_length, example_value, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(tableColumnSchemaId, input.tableSchemaId, input.columnCode, input.displayName, input.valueTypeCode ?? "TEXT", boolToInt(input.isRequired, 1), boolToInt(input.isNullable, 0), input.sortOrder ?? 0, input.codeSetRef ?? null, input.allowedValuesRef ?? null, input.validationRuleRef ?? null, input.pattern ?? null, input.minValue ?? null, input.maxValue ?? null, input.minLength ?? null, input.maxLength ?? null, input.exampleValue ?? null, input.description ?? null, jsonValue(input.metadata));
+        return tableColumnFromRow(this.getById("artifact_standard_table_column_schemas", "table_column_schema_id", tableColumnSchemaId));
+    }
+    listTableColumnSchemas(tableSchemaId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_table_column_schemas
+          WHERE table_schema_id = ?
+          ORDER BY sort_order, column_code`)
+            .all(tableSchemaId);
+        return rows.map(tableColumnFromRow);
+    }
+    addValidationRuleSet(validationRuleSetId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_validation_rule_sets
+           (validation_rule_set_id, artifact_standard_id, rule_set_code, rule_set_name,
+            target_domain, description, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(validationRuleSetId, input.artifactStandardId, input.ruleSetCode, input.ruleSetName, input.targetDomain ?? "artifact-standard", input.description ?? null, jsonValue(input.metadata));
+        return ruleSetFromRow(this.getById("artifact_standard_validation_rule_sets", "validation_rule_set_id", validationRuleSetId));
+    }
+    addValidationRuleSetRule(validationRuleSetRuleId, input) {
+        assertValidationContractCodes(input);
+        this.db
+            .prepare(`INSERT INTO artifact_standard_validation_rule_set_rules
+           (validation_rule_set_rule_id, validation_rule_set_id, rule_id, validation_type_code, execution_mode_code,
+            severity_code, applies_to_type_code, applies_to_ref, source_component_ref, parameters_json,
+            message, remediation, sort_order, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(validationRuleSetRuleId, input.validationRuleSetId, input.ruleId, input.validationTypeCode, input.executionModeCode, input.severityCode, input.appliesToTypeCode, input.appliesToRef ?? null, input.sourceComponentRef ?? null, jsonValue(input.parameters), input.message, input.remediation ?? null, input.sortOrder ?? 0, jsonValue(input.metadata));
+        return ruleSetRuleFromRow(this.getById("artifact_standard_validation_rule_set_rules", "validation_rule_set_rule_id", validationRuleSetRuleId));
+    }
+    listValidationRuleSetRules(validationRuleSetId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_validation_rule_set_rules
+          WHERE validation_rule_set_id = ?
+          ORDER BY sort_order, rule_id`)
+            .all(validationRuleSetId);
+        return rows.map(ruleSetRuleFromRow);
+    }
+    listValidationRuleSets(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_validation_rule_sets
+          WHERE artifact_standard_id = ?
+          ORDER BY rule_set_code`)
+            .all(artifactStandardId);
+        return rows.map(ruleSetFromRow);
+    }
+    exportValidationProviderManifest(providerId, artifactStandardId) {
+        const ruleSets = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_validation_rule_sets
+          WHERE artifact_standard_id = ?
+          ORDER BY rule_set_code`)
+            .all(artifactStandardId);
+        return {
+            providerId,
+            providerModule: "@soddong/agentic-domain-artifact-standard",
+            version: "0.11.0",
+            profiles: ruleSets.map((row) => {
+                const ruleSet = ruleSetFromRow(row);
+                const rules = this.listValidationRuleSetRules(ruleSet.validationRuleSetId).map(validationRuleContractFromRecord);
+                return {
+                    profileId: ruleSet.ruleSetCode,
+                    providerModule: "@soddong/agentic-domain-artifact-standard",
+                    targetDomain: ruleSet.targetDomain,
+                    rules,
+                    metadata: ruleSet.metadata
+                };
+            })
+        };
+    }
+    addGeneratedOutputLink(generatedOutputLinkId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_generated_output_links
+           (generated_output_link_id, link_code, source_artifact_standard_id, source_artifact_standard_code,
+            source_artifact_standard_version, target_type_code, target_artifact_standard_id,
+            target_artifact_standard_code, target_artifact_standard_version, target_output_name,
+            generation_mode_code, sort_order, description, is_active, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(generatedOutputLinkId, input.linkCode, input.sourceArtifactStandardId, input.sourceArtifactStandardCode, input.sourceArtifactStandardVersion, input.targetTypeCode, input.targetArtifactStandardId ?? null, input.targetArtifactStandardCode ?? null, input.targetArtifactStandardVersion ?? null, input.targetOutputName ?? null, input.generationModeCode ?? "AUTOMATIC", input.sortOrder ?? 0, input.description ?? null, boolToInt(input.isActive, 1), jsonValue(input.metadata));
+        return generatedOutputLinkFromRow(this.getById("artifact_standard_generated_output_links", "generated_output_link_id", generatedOutputLinkId));
+    }
+    getGeneratedOutputLinkByCode(linkCode) {
+        const row = this.db
+            .prepare(`SELECT * FROM artifact_standard_generated_output_links WHERE link_code = ?`)
+            .get(linkCode);
+        return row === undefined ? undefined : generatedOutputLinkFromRow(row);
+    }
+    listGeneratedOutputLinks() {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_generated_output_links
+          ORDER BY sort_order, link_code`)
+            .all();
+        return rows.map(generatedOutputLinkFromRow);
+    }
+    listGeneratedOutputLinksBySource(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_generated_output_links
+          WHERE source_artifact_standard_id = ?
+          ORDER BY sort_order, link_code`)
+            .all(artifactStandardId);
+        return rows.map(generatedOutputLinkFromRow);
+    }
+    addSourceMapping(sourceMappingId, input) {
+        this.db
+            .prepare(`INSERT INTO artifact_standard_source_mappings
+           (source_mapping_id, artifact_standard_id, source_type_code, source_uri, source_label,
+            source_section, source_fragment, target_type_code, target_ref, mapping_type_code,
+            mapping_status_code, rationale, loss_note, follow_up_note, metadata_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(sourceMappingId, input.artifactStandardId, input.sourceTypeCode, input.sourceUri, input.sourceLabel ?? null, input.sourceSection ?? null, input.sourceFragment ?? null, input.targetTypeCode, input.targetRef, input.mappingTypeCode, input.mappingStatusCode ?? "CANDIDATE", input.rationale ?? null, input.lossNote ?? null, input.followUpNote ?? null, jsonValue(input.metadata));
+        return sourceMappingFromRow(this.getById("artifact_standard_source_mappings", "source_mapping_id", sourceMappingId));
+    }
+    listSourceMappings(artifactStandardId) {
+        const rows = this.db
+            .prepare(`SELECT *
+           FROM artifact_standard_source_mappings
+          WHERE artifact_standard_id = ?
+          ORDER BY created_at, source_mapping_id`)
+            .all(artifactStandardId);
+        return rows.map(sourceMappingFromRow);
+    }
+    getById(tableName, idColumnName, id) {
+        const row = this.db.prepare(`SELECT * FROM ${tableName} WHERE ${idColumnName} = ?`).get(id);
+        if (row === undefined) {
+            throw new Error(`Record not found: ${tableName}.${idColumnName}=${id}`);
+        }
+        return row;
+    }
+}
+function assertValidationContractCodes(input) {
+    if (!isValidationTypeCode(input.validationTypeCode)) {
+        throw new Error(`Unsupported validation type code: ${input.validationTypeCode}`);
+    }
+    if (!isValidationExecutionModeCode(input.executionModeCode)) {
+        throw new Error(`Unsupported validation execution mode code: ${input.executionModeCode}`);
+    }
+    if (!isValidationSeverityCode(input.severityCode)) {
+        throw new Error(`Unsupported validation severity code: ${input.severityCode}`);
+    }
+    if (!artifactStandardValidationTargetTypeCodes.has(input.appliesToTypeCode)) {
+        throw new Error(`Unsupported artifact-standard validation target type code: ${input.appliesToTypeCode}`);
+    }
+}
+//# sourceMappingURL=repositories.js.map