@bilig/workbook 0.107.3 → 0.119.0

package/dist/schema.js

@@ -1,5 +1,8 @@
 import { workbookRunErrorCodes } from './result.js';
 import { workbookActionInputDescriptionKinds } from './input.js';
+import { cellStylePatchSchema, literalInputSchema, workbookOpSchema } from './op-schema.js';
+import { workbookActionCellStylePatchSchema, workbookCommandReceiptSchema, workbookRefDataDefSchemas, workbookRefDataSchemaRefs, workbookUndoRefSchema, } from './schema-fragments.js';
+import { createNoopEffectSchema, noopEffectCommandKindConditions } from './schema-noop.js';
 export const workbookJsonSchemaVersion = 'bilig-workbook-json-schema-v1';
 export const workbookJsonSchemaNames = Object.freeze([
     'refData',
@@ -12,11 +15,22 @@ export const workbookJsonSchemaNames = Object.freeze([
     'readbackProof',
 ]);
 const jsonValue = Object.freeze({ $ref: '#/$defs/jsonValue' });
+const literalInput = Object.freeze({ $ref: '#/$defs/literalInput' });
 const refData = Object.freeze({ $ref: '#/$defs/refData' });
 const cellRange = Object.freeze({ $ref: '#/$defs/cellRange' });
 const engineOp = Object.freeze({ $ref: '#/$defs/engineOp' });
 const actionInput = Object.freeze({ $ref: '#/$defs/actionInput' });
 const actionInputDescription = Object.freeze({ $ref: '#/$defs/actionInputDescription' });
+const exactString = Object.freeze({
+    type: 'string',
+    minLength: 1,
+    pattern: '^(?!\\s)(?![\\s\\S]*\\s$)[\\s\\S]+$',
+});
+const nonNegativeSafeInteger = Object.freeze({
+    type: 'integer',
+    minimum: 0,
+    maximum: Number.MAX_SAFE_INTEGER,
+});
 function defs(extra = {}) {
     return {
         jsonValue: {
@@ -29,6 +43,7 @@ function defs(extra = {}) {
                 { type: 'object', additionalProperties: { $ref: '#/$defs/jsonValue' } },
             ],
         },
+        literalInput: literalInputSchema,
         actionInput: { $ref: '#/$defs/jsonValue' },
         actionInputDescription: {
             type: 'object',
@@ -47,11 +62,11 @@ function defs(extra = {}) {
                 values: { type: 'array', minItems: 1, items: actionInput },
                 min: { type: 'number' },
                 max: { type: 'number' },
-                minLength: { type: 'integer', minimum: 0 },
-                maxLength: { type: 'integer', minimum: 0 },
+                minLength: nonNegativeSafeInteger,
+                maxLength: nonNegativeSafeInteger,
                 pattern: { type: 'string' },
-                minItems: { type: 'integer', minimum: 0 },
-                maxItems: { type: 'integer', minimum: 0 },
+                minItems: nonNegativeSafeInteger,
+                maxItems: nonNegativeSafeInteger,
                 additionalProperties: { type: 'boolean' },
                 default: actionInput,
                 examples: { type: 'array', minItems: 1, items: actionInput },
@@ -93,87 +108,21 @@ function defs(extra = {}) {
                 endAddress: { type: 'string', minLength: 1 },
             },
         },
-        engineOp: {
+        cellStylePatch: cellStylePatchSchema,
+        actionCellStylePatch: workbookActionCellStylePatchSchema,
+        formulaLabel: {
             type: 'object',
-            required: ['kind'],
+            required: ['name', 'ref'],
+            additionalProperties: false,
             properties: {
-                kind: { type: 'string', minLength: 1 },
+                name: { type: 'string', minLength: 1 },
+                ref: refData,
             },
-            additionalProperties: true,
         },
+        engineOp: workbookOpSchema,
+        ...workbookRefDataDefSchemas,
         refData: {
-            oneOf: [
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'range'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'range' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        range: { $ref: '#/$defs/cellRange' },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'name'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'name' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        name: { type: 'string', minLength: 1 },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'table' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        name: { type: 'string', minLength: 1 },
-                        sheetName: { type: 'string', minLength: 1 },
-                        headers: { type: 'array', items: { type: 'string' } },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'table', 'name'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'column' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        table: { $ref: '#/$defs/refData' },
-                        rows: { $ref: '#/$defs/refData' },
-                        name: { type: 'string', minLength: 1 },
-                    },
-                },
-                {
-                    type: 'object',
-                    required: ['kind', 'id', 'label', 'where'],
-                    additionalProperties: false,
-                    properties: {
-                        kind: { const: 'rows' },
-                        id: { type: 'string', minLength: 1 },
-                        label: { type: 'string', minLength: 1 },
-                        sheetName: { type: 'string', minLength: 1 },
-                        table: { $ref: '#/$defs/refData' },
-                        where: {
-                            type: 'object',
-                            required: ['column', 'op', 'value'],
-                            additionalProperties: false,
-                            properties: {
-                                column: { type: 'string', minLength: 1 },
-                                op: { enum: ['eq', 'neq', 'contains', 'startsWith', 'gt', 'gte', 'lt', 'lte'] },
-                                value: { $ref: '#/$defs/jsonValue' },
-                            },
-                        },
-                    },
-                },
-            ],
+            oneOf: workbookRefDataSchemaRefs,
         },
         concreteRefData: {
             type: 'object',
@@ -217,11 +166,35 @@ const checkDataSchema = {
         target: refData,
         refs: { type: 'array', items: refData },
         message: { type: 'string', minLength: 1 },
-        expectation: { type: 'object', additionalProperties: true },
+        expectation: { $ref: '#/$defs/checkExpectation' },
         proof: actionInput,
     },
     additionalProperties: false,
 };
+const checkExpectationSchema = {
+    oneOf: [
+        {
+            type: 'object',
+            required: ['kind', 'value'],
+            additionalProperties: false,
+            properties: {
+                kind: { const: 'valueEquals' },
+                value: literalInput,
+            },
+        },
+        {
+            type: 'object',
+            required: ['kind', 'formula', 'inputs', 'labels'],
+            additionalProperties: false,
+            properties: {
+                kind: { const: 'formulaEquals' },
+                formula: { type: 'string' },
+                inputs: { type: 'array', items: refData },
+                labels: { type: 'array', items: { $ref: '#/$defs/formulaLabel' } },
+            },
+        },
+    ],
+};
 const changeDataSchema = {
     type: 'object',
     required: ['kind', 'message'],
@@ -232,15 +205,6 @@ const changeDataSchema = {
         message: { type: 'string', minLength: 1 },
     },
 };
-const undoDataSchema = {
-    type: 'object',
-    required: ['id'],
-    additionalProperties: false,
-    properties: {
-        id: { type: 'string', minLength: 1 },
-        ops: { type: 'array', items: engineOp },
-    },
-};
 const unverifiedDataSchema = {
     type: 'object',
     required: ['kind', 'message'],
@@ -257,9 +221,9 @@ const runtimeRequirementSchema = {
     properties: {
         kind: { enum: ['apply', 'read', 'verify'] },
         capability: { enum: ['writeFormula', 'writeValue', 'format', 'clear', 'applyOp', 'read', 'verifyCheck'] },
-        commandIndex: { type: 'integer', minimum: 0 },
-        checkIndex: { type: 'integer', minimum: 0 },
-        opIndex: { type: 'integer', minimum: 0 },
+        commandIndex: nonNegativeSafeInteger,
+        checkIndex: nonNegativeSafeInteger,
+        opIndex: nonNegativeSafeInteger,
         opKind: { type: 'string', minLength: 1 },
         checkKind: { type: 'string', minLength: 1 },
         target: refData,
@@ -291,8 +255,8 @@ const applySummarySchema = {
     properties: {
         matched: { oneOf: [{ type: 'boolean' }, { type: 'null' }] },
         planId: { type: 'string', minLength: 1 },
-        baseRevision: { type: 'integer', minimum: 0 },
-        revision: { type: 'integer', minimum: 0 },
+        baseRevision: nonNegativeSafeInteger,
+        revision: nonNegativeSafeInteger,
         previewOps: { type: 'array', items: engineOp },
         appliedOps: { type: 'array', items: engineOp },
         commandReceipts: { type: 'array', items: { $ref: '#/$defs/applyCommandReceipt' } },
@@ -304,11 +268,33 @@ const applyCommandReceiptSchema = {
     required: ['commandIndex', 'commandKind', 'commandDigest', 'previewOps', 'appliedOps'],
     additionalProperties: false,
     properties: {
-        commandIndex: { type: 'integer', minimum: 0 },
+        commandIndex: nonNegativeSafeInteger,
         commandKind: { type: 'string', minLength: 1 },
         commandDigest: { type: 'string', minLength: 1 },
         previewOps: { type: 'array', items: engineOp },
         appliedOps: { type: 'array', items: engineOp },
+        noop: {
+            type: 'object',
+            required: ['reason', 'proof'],
+            additionalProperties: false,
+            properties: {
+                reason: { enum: ['already_satisfied'] },
+                message: { type: 'string', minLength: 1 },
+                proof: {
+                    type: 'object',
+                    required: ['source', 'evidence', 'opCount', 'commandKind', 'commandDigest', 'effect'],
+                    additionalProperties: true,
+                    properties: {
+                        source: exactString,
+                        evidence: exactString,
+                        opCount: { const: 0 },
+                        commandKind: exactString,
+                        commandDigest: exactString,
+                        effect: { $ref: '#/$defs/noopEffect' },
+                    },
+                },
+            },
+        },
         resolvedRefs: { $ref: '#/$defs/commandResolvedRefs' },
         formulaLabels: {
             type: 'array',
@@ -324,6 +310,19 @@ const applyCommandReceiptSchema = {
         },
         proof: actionInput,
     },
+    allOf: [
+        {
+            if: { required: ['noop'] },
+            // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+            then: {
+                properties: {
+                    previewOps: { type: 'array', maxItems: 0, items: engineOp },
+                    appliedOps: { type: 'array', maxItems: 0, items: engineOp },
+                },
+            },
+        },
+        ...noopEffectCommandKindConditions(),
+    ],
 };
 export const workbookJsonSchemas = deepFreeze({
     refData: schema('refData', {
@@ -356,15 +355,7 @@ export const workbookJsonSchemas = deepFreeze({
     }),
     planData: schema('planData', {
         $defs: defs({
-            formulaLabel: {
-                type: 'object',
-                required: ['name', 'ref'],
-                additionalProperties: false,
-                properties: {
-                    name: { type: 'string', minLength: 1 },
-                    ref: refData,
-                },
-            },
+            checkExpectation: checkExpectationSchema,
             check: checkDataSchema,
             command: {
                 oneOf: [
@@ -384,7 +375,7 @@ export const workbookJsonSchemas = deepFreeze({
                         type: 'object',
                         required: ['kind', 'target', 'value'],
                         additionalProperties: false,
-                        properties: { kind: { const: 'writeValue' }, target: refData, value: jsonValue },
+                        properties: { kind: { const: 'writeValue' }, target: refData, value: literalInput },
                     },
                     {
                         type: 'object',
@@ -393,9 +384,10 @@ export const workbookJsonSchemas = deepFreeze({
                         properties: {
                             kind: { const: 'format' },
                             target: refData,
-                            style: { type: 'object', additionalProperties: true },
+                            style: { $ref: '#/$defs/actionCellStylePatch' },
                             numberFormat: { oneOf: [{ type: 'string' }, { type: 'null' }] },
                         },
+                        anyOf: [{ required: ['style'] }, { required: ['numberFormat'] }],
                     },
                     {
                         type: 'object',
@@ -452,8 +444,8 @@ export const workbookJsonSchemas = deepFreeze({
                 required: ['featureId', 'commandId'],
                 additionalProperties: false,
                 properties: {
-                    featureId: { type: 'string', minLength: 1 },
-                    commandId: { type: 'string', minLength: 1 },
+                    featureId: exactString,
+                    commandId: exactString,
                     category: { enum: ['command', 'operation', 'mutation'] },
                     mode: { enum: ['preview', 'apply', 'applyAndVerify'] },
                     input: actionInput,
@@ -467,21 +459,57 @@ export const workbookJsonSchemas = deepFreeze({
                         additionalProperties: false,
                         properties: {
                             kind: { const: 'request' },
-                            id: { type: 'string', minLength: 1 },
+                            id: exactString,
                             touchedRanges: { type: 'array', items: cellRange },
                             destructive: { type: 'boolean' },
                             request: { $ref: '#/$defs/commandRequest' },
                         },
+                        allOf: [
+                            {
+                                if: {
+                                    properties: {
+                                        request: {
+                                            type: 'object',
+                                            properties: { category: { const: 'mutation' } },
+                                            required: ['category'],
+                                        },
+                                    },
+                                    required: ['request'],
+                                },
+                                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                then: {
+                                    required: ['destructive'],
+                                    properties: { destructive: { const: true } },
+                                },
+                            },
+                            {
+                                if: {
+                                    properties: {
+                                        request: {
+                                            type: 'object',
+                                            properties: { mode: { enum: ['apply', 'applyAndVerify'] } },
+                                            required: ['mode'],
+                                        },
+                                    },
+                                    required: ['request'],
+                                },
+                                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                then: {
+                                    required: ['destructive'],
+                                    properties: { destructive: { const: true } },
+                                },
+                            },
+                        ],
                     },
                     {
                         type: 'object',
-                        required: ['kind', 'op'],
+                        required: ['kind', 'destructive', 'op'],
                         additionalProperties: false,
                         properties: {
                             kind: { const: 'op' },
-                            id: { type: 'string', minLength: 1 },
+                            id: exactString,
                             touchedRanges: { type: 'array', items: cellRange },
-                            destructive: { type: 'boolean' },
+                            destructive: { const: true },
                             op: engineOp,
                         },
                     },
@@ -492,60 +520,152 @@ export const workbookJsonSchemas = deepFreeze({
         required: ['targetRevision', 'idempotencyKey', 'commands'],
         additionalProperties: false,
         properties: {
-            id: { type: 'string', minLength: 1 },
-            targetRevision: { type: 'integer', minimum: 0 },
-            idempotencyKey: { type: 'string', minLength: 1 },
+            id: exactString,
+            targetRevision: nonNegativeSafeInteger,
+            idempotencyKey: exactString,
             scope: {
                 type: 'object',
                 additionalProperties: false,
-                properties: { maxTouchedCells: { type: 'integer', minimum: 0 } },
+                properties: { maxTouchedCells: nonNegativeSafeInteger },
             },
             commands: { type: 'array', minItems: 1, items: { $ref: '#/$defs/bundleCommand' } },
         },
+        allOf: [
+            {
+                if: {
+                    properties: {
+                        scope: {
+                            type: 'object',
+                            required: ['maxTouchedCells'],
+                        },
+                    },
+                    required: ['scope'],
+                },
+                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                then: {
+                    properties: {
+                        commands: {
+                            items: {
+                                allOf: [
+                                    {
+                                        if: {
+                                            properties: { kind: { const: 'op' } },
+                                            required: ['kind'],
+                                        },
+                                        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                        then: {
+                                            required: ['touchedRanges'],
+                                            properties: { touchedRanges: { type: 'array', minItems: 1, items: cellRange } },
+                                        },
+                                    },
+                                    {
+                                        if: {
+                                            properties: {
+                                                kind: { const: 'request' },
+                                                request: {
+                                                    type: 'object',
+                                                    properties: { category: { const: 'mutation' } },
+                                                    required: ['category'],
+                                                },
+                                            },
+                                            required: ['kind', 'request'],
+                                        },
+                                        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                        then: {
+                                            required: ['touchedRanges'],
+                                            properties: { touchedRanges: { type: 'array', minItems: 1, items: cellRange } },
+                                        },
+                                    },
+                                    {
+                                        if: {
+                                            properties: {
+                                                kind: { const: 'request' },
+                                                request: {
+                                                    type: 'object',
+                                                    properties: { mode: { enum: ['apply', 'applyAndVerify'] } },
+                                                    required: ['mode'],
+                                                },
+                                            },
+                                            required: ['kind', 'request'],
+                                        },
+                                        // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                                        then: {
+                                            required: ['touchedRanges'],
+                                            properties: { touchedRanges: { type: 'array', minItems: 1, items: cellRange } },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+        ],
     }),
     commandResult: schema('commandResult', {
         $defs: defs({
-            receipt: {
-                type: 'object',
-                required: ['status', 'featureId', 'commandId', 'category'],
-                properties: {
-                    status: { enum: ['previewed', 'applied', 'rejected', 'noop'] },
-                    featureId: { type: 'string', minLength: 1 },
-                    commandId: { type: 'string', minLength: 1 },
-                    category: { enum: ['command', 'operation', 'mutation'] },
-                    previewOps: { type: 'array', items: engineOp },
-                    appliedOps: { type: 'array', items: engineOp },
-                    undo: { type: 'object', additionalProperties: true },
-                    changedRanges: { type: 'array', items: cellRange },
-                    proof: actionInput,
-                    message: { type: 'string' },
-                    metadata: actionInput,
-                    errors: { type: 'array', items: { type: 'string' } },
-                },
-                additionalProperties: false,
-            },
+            undo: workbookUndoRefSchema,
+            receipt: workbookCommandReceiptSchema,
         }),
         type: 'object',
         required: ['status', 'targetRevision', 'idempotencyKey', 'commandCount', 'touchedRanges', 'touchedCellCount'],
         additionalProperties: false,
         properties: {
             status: { enum: ['accepted', 'previewed', 'applied', 'rejected', 'noop'] },
-            bundleId: { type: 'string', minLength: 1 },
-            targetRevision: { type: 'integer', minimum: 0 },
-            idempotencyKey: { type: 'string', minLength: 1 },
-            commandCount: { type: 'integer', minimum: 0 },
+            bundleId: exactString,
+            targetRevision: nonNegativeSafeInteger,
+            idempotencyKey: exactString,
+            commandCount: nonNegativeSafeInteger,
             touchedRanges: { type: 'array', items: cellRange },
-            touchedCellCount: { type: 'integer', minimum: 0 },
+            touchedCellCount: nonNegativeSafeInteger,
             receipts: { type: 'array', items: { $ref: '#/$defs/receipt' } },
             matched: { oneOf: [{ type: 'boolean' }, { type: 'null' }] },
             changedRanges: { type: 'array', items: cellRange },
-            revision: { type: 'integer', minimum: 0 },
-            undo: { type: 'object', additionalProperties: true },
-            errors: { type: 'array', items: { type: 'string' } },
+            revision: nonNegativeSafeInteger,
+            undo: { $ref: '#/$defs/undo' },
+            errors: { type: 'array', items: exactString },
         },
+        allOf: [
+            {
+                if: { properties: { status: { const: 'accepted' } }, required: ['status'] },
+                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                then: {
+                    not: {
+                        anyOf: [
+                            { required: ['receipts'] },
+                            { required: ['matched'] },
+                            { required: ['changedRanges'] },
+                            { required: ['revision'] },
+                            { required: ['undo'] },
+                            { required: ['errors'] },
+                        ],
+                    },
+                },
+            },
+            {
+                if: {
+                    properties: { status: { enum: ['previewed', 'applied', 'rejected', 'noop'] } },
+                    required: ['status'],
+                },
+                // oxlint-disable-next-line eslint-plugin-unicorn(no-thenable) -- JSON Schema conditional schemas use the standard "then" keyword.
+                then: {
+                    required: ['receipts', 'matched', 'changedRanges'],
+                    properties: {
+                        receipts: { type: 'array', minItems: 1, items: { $ref: '#/$defs/receipt' } },
+                    },
+                },
+            },
+        ],
     }),
     runResult: schema('runResult', {
         $defs: defs({
+            noopEffect: createNoopEffectSchema({
+                literalInput,
+                exactString,
+                engineOp,
+                actionCellStylePatch: { $ref: '#/$defs/actionCellStylePatch' },
+            }),
+            checkExpectation: checkExpectationSchema,
             apply: applySummarySchema,
             applyCommandReceipt: applyCommandReceiptSchema,
             check: checkDataSchema,
@@ -561,7 +681,7 @@ export const workbookJsonSchemas = deepFreeze({
                     issueCode: { type: 'string' },
                 },
             },
-            undo: undoDataSchema,
+            undo: workbookUndoRefSchema,
             unverified: unverifiedDataSchema,
         }),
         oneOf: [
@@ -596,6 +716,7 @@ export const workbookJsonSchemas = deepFreeze({
     }),
     readbackProof: schema('readbackProof', {
         $defs: defs({
+            checkExpectation: checkExpectationSchema,
             check: checkDataSchema,
             readback: {
                 type: 'object',