@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/flow-publish-reviewed-data.d.ts

@@ -0,0 +1,262 @@
+import { type FlowRecord, type JsonRecord } from './flow-governance.js';
+import { type FlowPublishVersionReport, type RunFlowPublishVersionOptions } from './flow-publish-version.js';
+import type { FetchLike } from './http.js';
+import { type SupabaseJsonOrderedWriteOperation } from './supabase-json-ordered-write.js';
+export type FlowPublishPolicy = 'skip' | 'append_only_bump' | 'upsert_current_version';
+export type ProcessPublishPolicy = FlowPublishPolicy;
+type FlowPublishVersionCompatMode = 'dry_run' | 'commit';
+type FlowVersionMapEntry = {
+    id: string;
+    source_version: string;
+    target_version: string;
+};
+type ProcessIdentity = {
+    id: string;
+    version: string;
+    name: string;
+};
+type FlowIndex = {
+    byUuidVersion: Record<string, FlowRecord>;
+};
+type SkippedUnchangedFlowRow = {
+    entity_type: 'flow';
+    entity_id: string;
+    entity_name: string;
+    version: string;
+    reason: 'unchanged_vs_original_rows_file';
+};
+type PreparedFlowPlan = {
+    entity_type: 'flow';
+    entity_id: string;
+    entity_name: string;
+    original_version: string;
+    publish_version: string;
+    version_strategy: 'keep_current' | 'bump';
+    publish_policy: FlowPublishPolicy;
+    row: JsonRecord;
+};
+type PreparedProcessPlan = {
+    entity_type: 'process';
+    entity_id: string;
+    entity_name: string;
+    original_version: string;
+    publish_version: string;
+    version_strategy: 'keep_current' | 'bump';
+    publish_policy: ProcessPublishPolicy;
+    row: JsonRecord;
+};
+type ProcessFlowRefRewriteEvidence = {
+    process_id: string;
+    process_version_before_publish: string;
+    process_name: string;
+    exchange_internal_id: string;
+    source_flow_id: string;
+    source_flow_version: string;
+    target_flow_id: string;
+    target_flow_version: string;
+    target_flow_name: string;
+};
+type FlowPublishSuccessRow = {
+    id: string;
+    version: string;
+    operation: 'would_insert' | 'would_update_existing' | 'insert' | 'update_existing' | 'update_after_insert_error';
+};
+type FlowPublishFailureReason = {
+    validator: string;
+    stage: string;
+    path: string;
+    message: string;
+    code: string;
+    visible_user_id?: string;
+    visible_state_code?: string;
+};
+type FlowPublishFailureRow = {
+    id: unknown;
+    user_id?: unknown;
+    json_ordered: JsonRecord;
+    reason: FlowPublishFailureReason[];
+    state_code?: unknown;
+};
+type FlowReviewedPublishFiles = {
+    prepared_flow_rows: string;
+    prepared_process_rows: string;
+    flow_version_map: string;
+    skipped_unchanged_flow_rows: string;
+    process_ref_rewrite_evidence: string;
+    success_list: string;
+    remote_failed: string;
+    flow_publish_version_report: string;
+    report: string;
+};
+export type FlowReviewedPublishRowReport = {
+    entity_type: 'flow';
+    id: string;
+    name: string;
+    original_version: string;
+    publish_version: string;
+    publish_policy: FlowPublishPolicy;
+    version_strategy: 'keep_current' | 'bump';
+    status: 'prepared' | 'inserted' | 'updated' | 'failed';
+    operation?: FlowPublishSuccessRow['operation'];
+    error?: unknown;
+};
+export type FlowReviewedPublishProcessRowReport = {
+    entity_type: 'process';
+    id: string;
+    name: string;
+    original_version: string;
+    publish_version: string;
+    publish_policy: ProcessPublishPolicy;
+    version_strategy: 'keep_current' | 'bump';
+    status: 'prepared' | 'inserted' | 'updated' | 'skipped_existing' | 'failed';
+    operation?: SupabaseJsonOrderedWriteOperation;
+    error?: unknown;
+};
+export type FlowReviewedPublishDataReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'prepared_flow_publish_reviewed_data' | 'completed_flow_publish_reviewed_data' | 'completed_flow_publish_reviewed_data_with_failures';
+    mode: FlowPublishVersionCompatMode;
+    flow_rows_file: string | null;
+    process_rows_file: string | null;
+    original_flow_rows_file: string | null;
+    out_dir: string;
+    flow_publish_policy: FlowPublishPolicy;
+    process_publish_policy: ProcessPublishPolicy;
+    rewrite_process_flow_refs: boolean;
+    counts: {
+        input_flow_rows: number;
+        input_process_rows: number;
+        original_flow_rows: number;
+        prepared_flow_rows: number;
+        prepared_process_rows: number;
+        skipped_unchanged_flow_rows: number;
+        rewritten_process_flow_refs: number;
+        flow_publish_reports: number;
+        process_publish_reports: number;
+        success_count: number;
+        failure_count: number;
+    };
+    max_workers: number;
+    target_user_id_override: string | null;
+    files: FlowReviewedPublishFiles;
+    flow_reports: FlowReviewedPublishRowReport[];
+    process_reports: FlowReviewedPublishProcessRowReport[];
+    skipped_unchanged_flow_rows: SkippedUnchangedFlowRow[];
+};
+export type RunFlowReviewedPublishDataOptions = {
+    flowRowsFile?: string | null;
+    originalFlowRowsFile?: string | null;
+    processRowsFile?: string | null;
+    outDir: string;
+    flowPublishPolicy?: FlowPublishPolicy;
+    processPublishPolicy?: ProcessPublishPolicy;
+    rewriteProcessFlowRefs?: boolean;
+    commit?: boolean;
+    maxWorkers?: number;
+    targetUserId?: string | null;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    validateFlowPayloadImpl?: RunFlowPublishVersionOptions['validateFlowPayloadImpl'];
+    runFlowPublishVersionImpl?: (options: RunFlowPublishVersionOptions) => Promise<FlowPublishVersionReport>;
+};
+declare function assert_input_file(inputFile: string, code: string, message?: string): string;
+declare function assert_optional_input_file(inputFile: string | null | undefined, code: string): string | null;
+declare function assert_out_dir(outDir: string): string;
+declare function clone_json<T>(value: T): T;
+declare function json_equal(left: unknown, right: unknown): boolean;
+declare function normalize_publish_policy(value: FlowPublishPolicy | string | undefined, label?: string, code?: string): FlowPublishPolicy;
+declare function bump_ilcd_version(version: string): string;
+declare function set_flow_version(row: JsonRecord, newVersion: string): void;
+declare function process_dataset_from_row(row: JsonRecord): JsonRecord;
+declare function extract_process_identity(row: JsonRecord): ProcessIdentity;
+declare function exchange_records(processRow: JsonRecord): JsonRecord[];
+declare function set_process_version(row: JsonRecord, newVersion: string): void;
+declare function build_flow_index(rows: JsonRecord[]): FlowIndex;
+declare function build_local_dataset_uri(datasetKind: string, uuidValue: string, version: string): string;
+declare function preserve_short_description_shape(existing: unknown, target: JsonRecord): unknown;
+declare function flow_reference_from_record(record: FlowRecord): JsonRecord;
+declare function patched_flow_reference(currentRef: unknown, record: FlowRecord): JsonRecord;
+declare function build_output_files(outDir: string): FlowReviewedPublishFiles;
+declare function status_from_mode(mode: FlowPublishVersionCompatMode, failureCount: number): FlowReviewedPublishDataReport['status'];
+declare function prepare_flow_rows(options: {
+    rows: JsonRecord[];
+    policy: FlowPublishPolicy;
+    originalRows: JsonRecord[];
+}): {
+    preparedRows: JsonRecord[];
+    plans: PreparedFlowPlan[];
+    flowVersionMap: Record<string, FlowVersionMapEntry>;
+    skippedUnchangedRows: SkippedUnchangedFlowRow[];
+};
+declare function prepare_process_rows(options: {
+    rows: JsonRecord[];
+    policy: ProcessPublishPolicy;
+    rewriteRefs: boolean;
+    preparedFlowRows: JsonRecord[];
+    flowVersionMap: Record<string, FlowVersionMapEntry>;
+}): {
+    preparedRows: JsonRecord[];
+    plans: PreparedProcessPlan[];
+    rewriteEvidence: ProcessFlowRefRewriteEvidence[];
+};
+declare function process_publish_payload_from_row(row: JsonRecord): JsonRecord;
+declare function build_process_commit_success_report(plan: PreparedProcessPlan, operation: SupabaseJsonOrderedWriteOperation): FlowReviewedPublishProcessRowReport;
+declare function build_process_commit_failure_report(plan: PreparedProcessPlan, error: unknown): FlowReviewedPublishProcessRowReport;
+declare function normalize_process_commit_failure(error: unknown): unknown;
+declare function shift_queue<T>(queue: Map<string, T[]>, key: string | null): T | null;
+declare function map_with_concurrency<T, R>(items: T[], maxWorkers: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;
+declare function map_commit_reports(plans: PreparedFlowPlan[], successes: FlowPublishSuccessRow[], failures: FlowPublishFailureRow[]): FlowReviewedPublishRowReport[];
+declare function build_compat_report(options: {
+    now: Date;
+    mode: FlowPublishVersionCompatMode;
+    preparedRows: number;
+    successCount: number;
+    failureCount: number;
+    maxWorkers: number;
+    targetUserId: string | null;
+    files: FlowReviewedPublishFiles;
+}): FlowPublishVersionReport;
+declare function commit_process_plans(options: {
+    plans: PreparedProcessPlan[];
+    maxWorkers: number;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs?: number;
+}): Promise<FlowReviewedPublishProcessRowReport[]>;
+export declare function runFlowReviewedPublishData(options: RunFlowReviewedPublishDataOptions): Promise<FlowReviewedPublishDataReport>;
+export declare const __testInternals: {
+    assert_input_file: typeof assert_input_file;
+    assert_optional_input_file: typeof assert_optional_input_file;
+    assert_out_dir: typeof assert_out_dir;
+    clone_json: typeof clone_json;
+    json_equal: typeof json_equal;
+    normalize_publish_policy: typeof normalize_publish_policy;
+    bump_ilcd_version: typeof bump_ilcd_version;
+    set_flow_version: typeof set_flow_version;
+    process_dataset_from_row: typeof process_dataset_from_row;
+    extract_process_identity: typeof extract_process_identity;
+    exchange_records: typeof exchange_records;
+    set_process_version: typeof set_process_version;
+    build_flow_index: typeof build_flow_index;
+    build_local_dataset_uri: typeof build_local_dataset_uri;
+    preserve_short_description_shape: typeof preserve_short_description_shape;
+    flow_reference_from_record: typeof flow_reference_from_record;
+    patched_flow_reference: typeof patched_flow_reference;
+    build_output_files: typeof build_output_files;
+    status_from_mode: typeof status_from_mode;
+    prepare_flow_rows: typeof prepare_flow_rows;
+    prepare_process_rows: typeof prepare_process_rows;
+    build_compat_report: typeof build_compat_report;
+    map_commit_reports: typeof map_commit_reports;
+    shift_queue: typeof shift_queue;
+    process_publish_payload_from_row: typeof process_publish_payload_from_row;
+    build_process_commit_success_report: typeof build_process_commit_success_report;
+    build_process_commit_failure_report: typeof build_process_commit_failure_report;
+    normalize_process_commit_failure: typeof normalize_process_commit_failure;
+    map_with_concurrency: typeof map_with_concurrency;
+    commit_process_plans: typeof commit_process_plans;
+};
+export {};

package/dist/src/lib/flow-publish-version.d.ts

@@ -0,0 +1,193 @@
+import { type DatasetCommandTransport } from './dataset-command.js';
+import { type FlowPayloadValidationIssue, type FlowPayloadValidationResult } from './flow-payload-validation.js';
+import { type JsonRecord } from './flow-governance.js';
+import type { FetchLike, ResponseLike } from './http.js';
+import { createSupabaseDataClient } from './supabase-client.js';
+type FlowPublishMode = 'dry_run' | 'commit';
+type FlowPublishOperation = 'would_insert' | 'would_update_existing' | 'insert' | 'update_existing' | 'update_after_insert_error';
+type FlowPublishFailureReason = {
+    validator: 'remote_rest' | 'flow_schema' | 'import_content';
+    stage: string;
+    path: string;
+    message: string;
+    code: string;
+    visible_user_id?: string;
+    visible_state_code?: string;
+};
+type VisibleFlowRow = {
+    id: string;
+    version: string;
+    user_id: string;
+    state_code: number | null;
+};
+type SupabaseDataClient = ReturnType<typeof createSupabaseDataClient>['client'];
+type FlowPublishFailureRow = {
+    id: unknown;
+    user_id: unknown;
+    json_ordered: JsonRecord;
+    reason: FlowPublishFailureReason[];
+    state_code: unknown;
+};
+type FlowPublishSuccessRow = {
+    id: string;
+    version: string;
+    operation: FlowPublishOperation;
+};
+type FlowPublishFiles = {
+    successList: string;
+    remoteFailed: string;
+    gateReport: string;
+    report: string;
+};
+type FlowPublishGateFinding = {
+    code: string;
+    severity: 'blocker';
+    methodology_rule_id: string | null;
+    message: string;
+    path: string;
+    dataset_index: number;
+    dataset_id: string | null;
+    dataset_version: string | null;
+};
+export type FlowPublishVersionGateReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'passed' | 'blocked';
+    ruleset_id: 'flow-publish/default';
+    ruleset_version: '1';
+    ruleset_source_version: string;
+    ruleset_rule_ids: string[];
+    validator: string;
+    counts: {
+        total: number;
+        valid: number;
+        invalid: number;
+    };
+    findings: FlowPublishGateFinding[];
+    blockers: FlowPublishGateFinding[];
+    next_action: 'query_remote_write_plan' | 'fix_flow_payloads';
+    flows: Array<{
+        index: number;
+        id: string | null;
+        version: string | null;
+        ok: boolean;
+        issue_count: number;
+        issues: FlowPayloadValidationIssue[];
+    }>;
+};
+type FlowPublishOutcome = {
+    status: 'success';
+    success: FlowPublishSuccessRow;
+} | {
+    status: 'failure';
+    failure: FlowPublishFailureRow;
+};
+export type FlowPublishVersionReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'prepared_flow_publish_version' | 'completed_flow_publish_version' | 'completed_flow_publish_version_with_failures';
+    mode: FlowPublishMode;
+    input_file: string;
+    out_dir: string;
+    counts: {
+        total_rows: number;
+        success_count: number;
+        failure_count: number;
+    };
+    flow_gate: {
+        status: FlowPublishVersionGateReport['status'];
+        ruleset_id: FlowPublishVersionGateReport['ruleset_id'];
+        ruleset_version: FlowPublishVersionGateReport['ruleset_version'];
+        counts: FlowPublishVersionGateReport['counts'];
+        blocker_count: number;
+        next_action: FlowPublishVersionGateReport['next_action'];
+    };
+    operation_counts: Record<string, number>;
+    max_workers: number;
+    limit: number | null;
+    target_user_id_override: string | null;
+    files: {
+        success_list: string;
+        remote_failed: string;
+        gate_report: string;
+        report: string;
+    };
+};
+export type RunFlowPublishVersionOptions = {
+    inputFile: string;
+    outDir: string;
+    commit?: boolean;
+    maxWorkers?: number;
+    limit?: number;
+    targetUserId?: string | null;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    validateFlowPayloadImpl?: (payload: JsonRecord) => FlowPayloadValidationResult;
+};
+declare function assert_input_file(inputFile: string): string;
+declare function assert_out_dir(outDir: string): string;
+declare function to_positive_integer(value: number | undefined, label: string, code: string, defaultValue: number): number;
+declare function to_non_negative_integer(value: number | undefined, label: string, code: string): number | null;
+declare function build_output_files(outDir: string): FlowPublishFiles;
+declare function flow_payload(row: JsonRecord): JsonRecord;
+declare function flow_id(row: JsonRecord, payload: JsonRecord): string;
+declare function flow_version(payload: JsonRecord): string;
+declare function flow_version_gate_result(payload: JsonRecord): {
+    version: string | null;
+    issue: FlowPayloadValidationIssue | null;
+};
+declare function validate_publish_flow_row(row: JsonRecord, index: number, validate: (payload: JsonRecord) => FlowPayloadValidationResult): FlowPublishVersionGateReport['flows'][number];
+declare function build_flow_publish_gate_report(rows: JsonRecord[], options: {
+    now: Date;
+    validateFlowPayloadImpl?: (payload: JsonRecord) => FlowPayloadValidationResult;
+}): FlowPublishVersionGateReport;
+declare function flow_gate_summary(gate: FlowPublishVersionGateReport): FlowPublishVersionReport['flow_gate'];
+declare function gate_failure_rows(rows: JsonRecord[], gate: FlowPublishVersionGateReport): FlowPublishFailureRow[];
+declare function resolve_target_user_id(row: JsonRecord, targetUserIdOverride: string | null): string | null;
+declare function build_visible_rows_url(restBaseUrl: string, id: string, version: string): string;
+declare function build_update_url(restBaseUrl: string, id: string, version: string): string;
+declare function parse_response(response: ResponseLike, url: string): Promise<unknown>;
+declare function parse_visible_rows(payload: unknown, url: string): VisibleFlowRow[];
+declare function visible_conflict_reasons(stage: string, visibleRows: VisibleFlowRow[], targetUserId: string | null): FlowPublishFailureReason[];
+declare function failure_row(sourceRow: JsonRecord, reasons: FlowPublishFailureReason[]): FlowPublishFailureRow;
+declare function build_error_reasons(stage: string, error: unknown): FlowPublishFailureReason[];
+declare function sync_one_row(options: {
+    row: JsonRecord;
+    mode: FlowPublishMode;
+    client: SupabaseDataClient;
+    restBaseUrl: string;
+    commandTransport: DatasetCommandTransport;
+    targetUserIdOverride: string | null;
+}): Promise<FlowPublishOutcome>;
+declare function map_with_concurrency<T, R>(items: T[], maxWorkers: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;
+declare function status_from_mode(mode: FlowPublishMode, failureCount: number): FlowPublishVersionReport['status'];
+export declare function runFlowPublishVersion(options: RunFlowPublishVersionOptions): Promise<FlowPublishVersionReport>;
+export declare const __testInternals: {
+    assert_input_file: typeof assert_input_file;
+    assert_out_dir: typeof assert_out_dir;
+    to_positive_integer: typeof to_positive_integer;
+    to_non_negative_integer: typeof to_non_negative_integer;
+    build_output_files: typeof build_output_files;
+    flow_payload: typeof flow_payload;
+    flow_id: typeof flow_id;
+    flow_version: typeof flow_version;
+    flow_version_gate_result: typeof flow_version_gate_result;
+    validate_publish_flow_row: typeof validate_publish_flow_row;
+    build_flow_publish_gate_report: typeof build_flow_publish_gate_report;
+    flow_gate_summary: typeof flow_gate_summary;
+    gate_failure_rows: typeof gate_failure_rows;
+    sync_one_row: typeof sync_one_row;
+    resolve_target_user_id: typeof resolve_target_user_id;
+    build_visible_rows_url: typeof build_visible_rows_url;
+    build_update_url: typeof build_update_url;
+    parse_response: typeof parse_response;
+    parse_visible_rows: typeof parse_visible_rows;
+    visible_conflict_reasons: typeof visible_conflict_reasons;
+    failure_row: typeof failure_row;
+    build_error_reasons: typeof build_error_reasons;
+    map_with_concurrency: typeof map_with_concurrency;
+    status_from_mode: typeof status_from_mode;
+};
+export {};