@tinyshed/tinystore 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -36,6 +36,10 @@ export const methods = {
36
36
  'blobs.usage': 0x040b,
37
37
  'blobs.clear': 0x040c,
38
38
  'blobs.read': 0x040d,
39
+ 'blobs.directory': 0x040e,
40
+ 'blobs.scan': 0x040f,
41
+ 'blobs.changes': 0x0410,
42
+ 'blobs.forget': 0x0411,
39
43
  /**
40
44
  * Answers once the store has the message, not once anyone handled it; in a
41
45
  * database's transaction, it is handed over once the transaction commits.
@@ -68,6 +72,7 @@ export const methods = {
68
72
  'jobs.keep': 0x020b,
69
73
  'jobs.watch': 0x020c,
70
74
  'jobs.tx': 0x020d,
75
+ 'jobs.counts': 0x020e,
71
76
  'kv.bucket.open': 0x0101,
72
77
  'kv.get': 0x0102,
73
78
  'kv.has': 0x0103,
@@ -280,6 +285,8 @@ export const BackupWritten = message(
280
285
  bytes: [2, uint],
281
286
  /** the store seals values with a key the backup does not hold */
282
287
  keyLeftOut: [3, bool],
288
+ /** the databases opened with backup false, which it holds nothing of */
289
+ excluded: [4, list(str)],
283
290
  },
284
291
  {
285
292
  write(w, v) {
@@ -300,12 +307,21 @@ export const BackupWritten = message(
300
307
  w.bool(v.keyLeftOut)
301
308
  n++
302
309
  }
310
+ if (v.excluded !== undefined) {
311
+ w.field(4)
312
+ w.array(v.excluded.length)
313
+ for (const item0 of v.excluded) {
314
+ w.str(item0)
315
+ }
316
+ n++
317
+ }
303
318
  w.closeMap(head, n)
304
319
  },
305
320
  read(r) {
306
321
  let $files: number | undefined
307
322
  let $bytes: number | undefined
308
323
  let $keyLeftOut: boolean | undefined
324
+ let $excluded: string[] | undefined
309
325
  for (let n = r.message(); n > 0; n--) {
310
326
  switch (r.field()) {
311
327
  case 1:
@@ -317,12 +333,21 @@ export const BackupWritten = message(
317
333
  case 3:
318
334
  $keyLeftOut = r.bool()
319
335
  break
336
+ case 4: {
337
+ const items0: string[] = []
338
+ for (let i0 = r.array(); i0 > 0; i0--) {
339
+ items0.push(r.str())
340
+ }
341
+ r.leave()
342
+ $excluded = items0
343
+ break
344
+ }
320
345
  default:
321
346
  r.skip()
322
347
  }
323
348
  }
324
349
  r.leave()
325
- return { files: $files, bytes: $bytes, keyLeftOut: $keyLeftOut }
350
+ return { files: $files, bytes: $bytes, keyLeftOut: $keyLeftOut, excluded: $excluded }
326
351
  },
327
352
  },
328
353
  )
@@ -758,12 +783,15 @@ export const BlobsWritten = message(
758
783
 
759
784
  /**
760
785
  * A piece of a file's bytes: an upload's DATA from the client, a read's from
761
- * the server.
786
+ * the server. A piece of a growing directory's file brings the file's size
787
+ * and time as it was read, so that the reader sees it moved.
762
788
  */
763
789
  export const BlobsPiece = message(
764
790
  'blobs.Piece',
765
791
  {
766
792
  bytes: [1, bin],
793
+ size: [2, uint],
794
+ lastModified: [3, int],
767
795
  },
768
796
  {
769
797
  write(w, v) {
@@ -774,21 +802,39 @@ export const BlobsPiece = message(
774
802
  w.bin(v.bytes)
775
803
  n++
776
804
  }
805
+ if (v.size !== undefined) {
806
+ w.field(2)
807
+ w.uint(v.size)
808
+ n++
809
+ }
810
+ if (v.lastModified !== undefined) {
811
+ w.field(3)
812
+ w.int(v.lastModified)
813
+ n++
814
+ }
777
815
  w.closeMap(head, n)
778
816
  },
779
817
  read(r) {
780
818
  let $bytes: Uint8Array | undefined
819
+ let $size: number | undefined
820
+ let $lastModified: number | undefined
781
821
  for (let n = r.message(); n > 0; n--) {
782
822
  switch (r.field()) {
783
823
  case 1:
784
824
  $bytes = r.bytes()
785
825
  break
826
+ case 2:
827
+ $size = r.uint()
828
+ break
829
+ case 3:
830
+ $lastModified = r.int()
831
+ break
786
832
  default:
787
833
  r.skip()
788
834
  }
789
835
  }
790
836
  r.leave()
791
- return { bytes: $bytes }
837
+ return { bytes: $bytes, size: $size, lastModified: $lastModified }
792
838
  },
793
839
  },
794
840
  )
@@ -1480,6 +1526,356 @@ export const BlobsUsage = message(
1480
1526
  },
1481
1527
  )
1482
1528
 
1529
+ /**
1530
+ * Opens a directory by name: a folder of the server's machine, which the
1531
+ * store lists and reads and never writes. Its handle takes get, head, list,
1532
+ * usage and read as a set of files' does, each answered from the list the
1533
+ * last scan wrote but a get's and a read's bytes, which come from the disk;
1534
+ * every call that writes a file is invalid. A connection that came with a
1535
+ * token names no path: it opens the directory the server was given under the
1536
+ * name, and one the server was not given is invalid.
1537
+ */
1538
+ export const BlobsDirectory = message(
1539
+ 'blobs.Directory',
1540
+ {
1541
+ /** [a-z0-9][a-z0-9_-]{0,63}, never a set of files' name too */
1542
+ name: [1, str],
1543
+ /** the folder on the server's machine; the server's own when absent */
1544
+ path: [2, str],
1545
+ /** a scan on the store's background work, a period apart */
1546
+ every: [3, uint],
1547
+ /** names a scan passes over, * for any run of a name's characters */
1548
+ ignore: [4, list(str)],
1549
+ /** a read holds to no version and goes up to the size now */
1550
+ growing: [5, bool],
1551
+ },
1552
+ {
1553
+ write(w, v) {
1554
+ const head = w.openMap()
1555
+ let n = 0
1556
+ if (v.name !== undefined) {
1557
+ w.field(1)
1558
+ w.str(v.name)
1559
+ n++
1560
+ }
1561
+ if (v.path !== undefined) {
1562
+ w.field(2)
1563
+ w.str(v.path)
1564
+ n++
1565
+ }
1566
+ if (v.every !== undefined) {
1567
+ w.field(3)
1568
+ w.uint(v.every)
1569
+ n++
1570
+ }
1571
+ if (v.ignore !== undefined) {
1572
+ w.field(4)
1573
+ w.array(v.ignore.length)
1574
+ for (const item0 of v.ignore) {
1575
+ w.str(item0)
1576
+ }
1577
+ n++
1578
+ }
1579
+ if (v.growing !== undefined) {
1580
+ w.field(5)
1581
+ w.bool(v.growing)
1582
+ n++
1583
+ }
1584
+ w.closeMap(head, n)
1585
+ },
1586
+ read(r) {
1587
+ let $name: string | undefined
1588
+ let $path: string | undefined
1589
+ let $every: number | undefined
1590
+ let $ignore: string[] | undefined
1591
+ let $growing: boolean | undefined
1592
+ for (let n = r.message(); n > 0; n--) {
1593
+ switch (r.field()) {
1594
+ case 1:
1595
+ $name = r.str()
1596
+ break
1597
+ case 2:
1598
+ $path = r.str()
1599
+ break
1600
+ case 3:
1601
+ $every = r.uint()
1602
+ break
1603
+ case 4: {
1604
+ const items0: string[] = []
1605
+ for (let i0 = r.array(); i0 > 0; i0--) {
1606
+ items0.push(r.str())
1607
+ }
1608
+ r.leave()
1609
+ $ignore = items0
1610
+ break
1611
+ }
1612
+ case 5:
1613
+ $growing = r.bool()
1614
+ break
1615
+ default:
1616
+ r.skip()
1617
+ }
1618
+ }
1619
+ r.leave()
1620
+ return { name: $name, path: $path, every: $every, ignore: $ignore, growing: $growing }
1621
+ },
1622
+ },
1623
+ )
1624
+
1625
+ /**
1626
+ * What a scan found, and what the list holds once it ended.
1627
+ */
1628
+ export const BlobsScanned = message(
1629
+ 'blobs.Scanned',
1630
+ {
1631
+ added: [1, uint],
1632
+ changed: [2, uint],
1633
+ removed: [3, uint],
1634
+ /** what it met and could not list: a link, a folder it cannot read, another disk */
1635
+ skipped: [4, uint],
1636
+ count: [5, uint],
1637
+ size: [6, uint],
1638
+ },
1639
+ {
1640
+ write(w, v) {
1641
+ const head = w.openMap()
1642
+ let n = 0
1643
+ if (v.added !== undefined) {
1644
+ w.field(1)
1645
+ w.uint(v.added)
1646
+ n++
1647
+ }
1648
+ if (v.changed !== undefined) {
1649
+ w.field(2)
1650
+ w.uint(v.changed)
1651
+ n++
1652
+ }
1653
+ if (v.removed !== undefined) {
1654
+ w.field(3)
1655
+ w.uint(v.removed)
1656
+ n++
1657
+ }
1658
+ if (v.skipped !== undefined) {
1659
+ w.field(4)
1660
+ w.uint(v.skipped)
1661
+ n++
1662
+ }
1663
+ if (v.count !== undefined) {
1664
+ w.field(5)
1665
+ w.uint(v.count)
1666
+ n++
1667
+ }
1668
+ if (v.size !== undefined) {
1669
+ w.field(6)
1670
+ w.uint(v.size)
1671
+ n++
1672
+ }
1673
+ w.closeMap(head, n)
1674
+ },
1675
+ read(r) {
1676
+ let $added: number | undefined
1677
+ let $changed: number | undefined
1678
+ let $removed: number | undefined
1679
+ let $skipped: number | undefined
1680
+ let $count: number | undefined
1681
+ let $size: number | undefined
1682
+ for (let n = r.message(); n > 0; n--) {
1683
+ switch (r.field()) {
1684
+ case 1:
1685
+ $added = r.uint()
1686
+ break
1687
+ case 2:
1688
+ $changed = r.uint()
1689
+ break
1690
+ case 3:
1691
+ $removed = r.uint()
1692
+ break
1693
+ case 4:
1694
+ $skipped = r.uint()
1695
+ break
1696
+ case 5:
1697
+ $count = r.uint()
1698
+ break
1699
+ case 6:
1700
+ $size = r.uint()
1701
+ break
1702
+ default:
1703
+ r.skip()
1704
+ }
1705
+ }
1706
+ r.leave()
1707
+ return {
1708
+ added: $added,
1709
+ changed: $changed,
1710
+ removed: $removed,
1711
+ skipped: $skipped,
1712
+ count: $count,
1713
+ size: $size,
1714
+ }
1715
+ },
1716
+ },
1717
+ )
1718
+
1719
+ /**
1720
+ * The changes of a directory past a cursor, from the first file it listed
1721
+ * when absent.
1722
+ */
1723
+ export const BlobsSince = message(
1724
+ 'blobs.Since',
1725
+ {
1726
+ handle: [1, uint],
1727
+ /** a page's next */
1728
+ after: [2, str],
1729
+ },
1730
+ {
1731
+ write(w, v) {
1732
+ const head = w.openMap()
1733
+ let n = 0
1734
+ if (v.handle !== undefined) {
1735
+ w.field(1)
1736
+ w.uint(v.handle)
1737
+ n++
1738
+ }
1739
+ if (v.after !== undefined) {
1740
+ w.field(2)
1741
+ w.str(v.after)
1742
+ n++
1743
+ }
1744
+ w.closeMap(head, n)
1745
+ },
1746
+ read(r) {
1747
+ let $handle: number | undefined
1748
+ let $after: string | undefined
1749
+ for (let n = r.message(); n > 0; n--) {
1750
+ switch (r.field()) {
1751
+ case 1:
1752
+ $handle = r.uint()
1753
+ break
1754
+ case 2:
1755
+ $after = r.str()
1756
+ break
1757
+ default:
1758
+ r.skip()
1759
+ }
1760
+ }
1761
+ r.leave()
1762
+ return { handle: $handle, after: $after }
1763
+ },
1764
+ },
1765
+ )
1766
+
1767
+ export const BlobsChange = message(
1768
+ 'blobs.Change',
1769
+ {
1770
+ /** the whole path in the directory */
1771
+ path: [1, str],
1772
+ /** added, changed or removed */
1773
+ change: [2, str],
1774
+ /** none once removed */
1775
+ info: [3, BlobsInfo],
1776
+ },
1777
+ {
1778
+ write(w, v) {
1779
+ const head = w.openMap()
1780
+ let n = 0
1781
+ if (v.path !== undefined) {
1782
+ w.field(1)
1783
+ w.str(v.path)
1784
+ n++
1785
+ }
1786
+ if (v.change !== undefined) {
1787
+ w.field(2)
1788
+ w.str(v.change)
1789
+ n++
1790
+ }
1791
+ if (v.info !== undefined) {
1792
+ w.field(3)
1793
+ BlobsInfo.write(w, v.info)
1794
+ n++
1795
+ }
1796
+ w.closeMap(head, n)
1797
+ },
1798
+ read(r) {
1799
+ let $path: string | undefined
1800
+ let $change: string | undefined
1801
+ let $info: Read<typeof BlobsInfo.fields> | undefined
1802
+ for (let n = r.message(); n > 0; n--) {
1803
+ switch (r.field()) {
1804
+ case 1:
1805
+ $path = r.str()
1806
+ break
1807
+ case 2:
1808
+ $change = r.str()
1809
+ break
1810
+ case 3:
1811
+ $info = BlobsInfo.read(r)
1812
+ break
1813
+ default:
1814
+ r.skip()
1815
+ }
1816
+ }
1817
+ r.leave()
1818
+ return { path: $path, change: $change, info: $info }
1819
+ },
1820
+ },
1821
+ )
1822
+
1823
+ /**
1824
+ * A page of changes in the order the scans wrote them, 1000 at most; next is
1825
+ * always there, with no items the cursor to ask from after the next scan.
1826
+ */
1827
+ export const BlobsChanges = message(
1828
+ 'blobs.Changes',
1829
+ {
1830
+ items: [1, list(BlobsChange)],
1831
+ next: [2, str],
1832
+ },
1833
+ {
1834
+ write(w, v) {
1835
+ const head = w.openMap()
1836
+ let n = 0
1837
+ if (v.items !== undefined) {
1838
+ w.field(1)
1839
+ w.array(v.items.length)
1840
+ for (const item0 of v.items) {
1841
+ BlobsChange.write(w, item0)
1842
+ }
1843
+ n++
1844
+ }
1845
+ if (v.next !== undefined) {
1846
+ w.field(2)
1847
+ w.str(v.next)
1848
+ n++
1849
+ }
1850
+ w.closeMap(head, n)
1851
+ },
1852
+ read(r) {
1853
+ let $items: Read<typeof BlobsChange.fields>[] | undefined
1854
+ let $next: string | undefined
1855
+ for (let n = r.message(); n > 0; n--) {
1856
+ switch (r.field()) {
1857
+ case 1: {
1858
+ const items0: Read<typeof BlobsChange.fields>[] = []
1859
+ for (let i0 = r.array(); i0 > 0; i0--) {
1860
+ items0.push(BlobsChange.read(r))
1861
+ }
1862
+ r.leave()
1863
+ $items = items0
1864
+ break
1865
+ }
1866
+ case 2:
1867
+ $next = r.str()
1868
+ break
1869
+ default:
1870
+ r.skip()
1871
+ }
1872
+ }
1873
+ r.leave()
1874
+ return { items: $items, next: $next }
1875
+ },
1876
+ },
1877
+ )
1878
+
1483
1879
  /**
1484
1880
  * A message published on a channel's branch, as docs/guides/channels/README.md has
1485
1881
  * it: every subscription listening there now receives it.
@@ -3213,13 +3609,15 @@ export const JobsCall = message(
3213
3609
  )
3214
3610
 
3215
3611
  /**
3216
- * The job under an id.
3612
+ * The job under an id; or, for a cancel, a job without one by the row a page
3613
+ * gave, its id left out.
3217
3614
  */
3218
3615
  export const JobsId = message(
3219
3616
  'jobs.Id',
3220
3617
  {
3221
3618
  handle: [1, uint],
3222
3619
  id: [2, str],
3620
+ row: [3, str],
3223
3621
  },
3224
3622
  {
3225
3623
  write(w, v) {
@@ -3235,11 +3633,17 @@ export const JobsId = message(
3235
3633
  w.str(v.id)
3236
3634
  n++
3237
3635
  }
3636
+ if (v.row !== undefined) {
3637
+ w.field(3)
3638
+ w.str(v.row)
3639
+ n++
3640
+ }
3238
3641
  w.closeMap(head, n)
3239
3642
  },
3240
3643
  read(r) {
3241
3644
  let $handle: number | undefined
3242
3645
  let $id: string | undefined
3646
+ let $row: string | undefined
3243
3647
  for (let n = r.message(); n > 0; n--) {
3244
3648
  switch (r.field()) {
3245
3649
  case 1:
@@ -3248,12 +3652,15 @@ export const JobsId = message(
3248
3652
  case 2:
3249
3653
  $id = r.str()
3250
3654
  break
3655
+ case 3:
3656
+ $row = r.str()
3657
+ break
3251
3658
  default:
3252
3659
  r.skip()
3253
3660
  }
3254
3661
  }
3255
3662
  r.leave()
3256
- return { handle: $handle, id: $id }
3663
+ return { handle: $handle, id: $id, row: $row }
3257
3664
  },
3258
3665
  },
3259
3666
  )
@@ -3319,6 +3726,10 @@ export const JobsJob = message(
3319
3726
  /** the last run a handler finished */
3320
3727
  startedAt: [12, int],
3321
3728
  endedAt: [13, int],
3729
+ /** where a job without an id lies, which a cancel names it by */
3730
+ row: [14, str],
3731
+ /** a walk's: why the job's value no longer reads, the job left out */
3732
+ failure: [15, Failure],
3322
3733
  },
3323
3734
  {
3324
3735
  write(w, v) {
@@ -3389,6 +3800,16 @@ export const JobsJob = message(
3389
3800
  w.int(v.endedAt)
3390
3801
  n++
3391
3802
  }
3803
+ if (v.row !== undefined) {
3804
+ w.field(14)
3805
+ w.str(v.row)
3806
+ n++
3807
+ }
3808
+ if (v.failure !== undefined) {
3809
+ w.field(15)
3810
+ Failure.write(w, v.failure)
3811
+ n++
3812
+ }
3392
3813
  w.closeMap(head, n)
3393
3814
  },
3394
3815
  read(r) {
@@ -3405,6 +3826,8 @@ export const JobsJob = message(
3405
3826
  let $repeat: string | undefined
3406
3827
  let $startedAt: number | undefined
3407
3828
  let $endedAt: number | undefined
3829
+ let $row: string | undefined
3830
+ let $failure: Read<typeof Failure.fields> | undefined
3408
3831
  for (let n = r.message(); n > 0; n--) {
3409
3832
  switch (r.field()) {
3410
3833
  case 1:
@@ -3446,6 +3869,12 @@ export const JobsJob = message(
3446
3869
  case 13:
3447
3870
  $endedAt = r.int()
3448
3871
  break
3872
+ case 14:
3873
+ $row = r.str()
3874
+ break
3875
+ case 15:
3876
+ $failure = Failure.read(r)
3877
+ break
3449
3878
  default:
3450
3879
  r.skip()
3451
3880
  }
@@ -3465,6 +3894,8 @@ export const JobsJob = message(
3465
3894
  repeat: $repeat,
3466
3895
  startedAt: $startedAt,
3467
3896
  endedAt: $endedAt,
3897
+ row: $row,
3898
+ failure: $failure,
3468
3899
  }
3469
3900
  },
3470
3901
  },
@@ -3487,6 +3918,8 @@ export const JobsList = message(
3487
3918
  after: [4, str],
3488
3919
  /** 100 when absent, 1000 at most */
3489
3920
  limit: [5, uint],
3921
+ /** a job whose value no longer reads comes as its failure in its place, not the page's */
3922
+ walk: [6, bool],
3490
3923
  },
3491
3924
  {
3492
3925
  write(w, v) {
@@ -3517,6 +3950,11 @@ export const JobsList = message(
3517
3950
  w.uint(v.limit)
3518
3951
  n++
3519
3952
  }
3953
+ if (v.walk !== undefined) {
3954
+ w.field(6)
3955
+ w.bool(v.walk)
3956
+ n++
3957
+ }
3520
3958
  w.closeMap(head, n)
3521
3959
  },
3522
3960
  read(r) {
@@ -3525,6 +3963,7 @@ export const JobsList = message(
3525
3963
  let $state: string | undefined
3526
3964
  let $after: string | undefined
3527
3965
  let $limit: number | undefined
3966
+ let $walk: boolean | undefined
3528
3967
  for (let n = r.message(); n > 0; n--) {
3529
3968
  switch (r.field()) {
3530
3969
  case 1:
@@ -3542,12 +3981,22 @@ export const JobsList = message(
3542
3981
  case 5:
3543
3982
  $limit = r.uint()
3544
3983
  break
3984
+ case 6:
3985
+ $walk = r.bool()
3986
+ break
3545
3987
  default:
3546
3988
  r.skip()
3547
3989
  }
3548
3990
  }
3549
3991
  r.leave()
3550
- return { handle: $handle, prefix: $prefix, state: $state, after: $after, limit: $limit }
3992
+ return {
3993
+ handle: $handle,
3994
+ prefix: $prefix,
3995
+ state: $state,
3996
+ after: $after,
3997
+ limit: $limit,
3998
+ walk: $walk,
3999
+ }
3551
4000
  },
3552
4001
  },
3553
4002
  )
@@ -3604,6 +4053,76 @@ export const JobsPage = message(
3604
4053
  },
3605
4054
  )
3606
4055
 
4056
+ /**
4057
+ * How many jobs a queue holds in each state, from one snapshot; a done job
4058
+ * has left it.
4059
+ */
4060
+ export const JobsCounts = message(
4061
+ 'jobs.Counts',
4062
+ {
4063
+ /** due later */
4064
+ scheduled: [1, uint],
4065
+ /** due, and no handler runs it yet */
4066
+ waiting: [2, uint],
4067
+ running: [3, uint],
4068
+ /** kept for the queue's keep */
4069
+ failed: [4, uint],
4070
+ },
4071
+ {
4072
+ write(w, v) {
4073
+ const head = w.openMap()
4074
+ let n = 0
4075
+ if (v.scheduled !== undefined) {
4076
+ w.field(1)
4077
+ w.uint(v.scheduled)
4078
+ n++
4079
+ }
4080
+ if (v.waiting !== undefined) {
4081
+ w.field(2)
4082
+ w.uint(v.waiting)
4083
+ n++
4084
+ }
4085
+ if (v.running !== undefined) {
4086
+ w.field(3)
4087
+ w.uint(v.running)
4088
+ n++
4089
+ }
4090
+ if (v.failed !== undefined) {
4091
+ w.field(4)
4092
+ w.uint(v.failed)
4093
+ n++
4094
+ }
4095
+ w.closeMap(head, n)
4096
+ },
4097
+ read(r) {
4098
+ let $scheduled: number | undefined
4099
+ let $waiting: number | undefined
4100
+ let $running: number | undefined
4101
+ let $failed: number | undefined
4102
+ for (let n = r.message(); n > 0; n--) {
4103
+ switch (r.field()) {
4104
+ case 1:
4105
+ $scheduled = r.uint()
4106
+ break
4107
+ case 2:
4108
+ $waiting = r.uint()
4109
+ break
4110
+ case 3:
4111
+ $running = r.uint()
4112
+ break
4113
+ case 4:
4114
+ $failed = r.uint()
4115
+ break
4116
+ default:
4117
+ r.skip()
4118
+ }
4119
+ }
4120
+ r.leave()
4121
+ return { scheduled: $scheduled, waiting: $waiting, running: $running, failed: $failed }
4122
+ },
4123
+ },
4124
+ )
4125
+
3607
4126
  /**
3608
4127
  * Starts the queue's worker for the client: the server claims its jobs as they
3609
4128
  * fall due and hands each over as a held job, no more at once than the
@@ -3972,7 +4491,7 @@ export const JobsKept = message(
3972
4491
 
3973
4492
  /**
3974
4493
  * One write of a transaction: an add, a set or an update with its call, or a
3975
- * cancel with its id.
4494
+ * cancel with its id or its row.
3976
4495
  */
3977
4496
  export const JobsOp = message(
3978
4497
  'jobs.Op',
@@ -6292,6 +6811,8 @@ export const MetricsAggregateAsked = message(
6292
6811
  calendar: [7, str],
6293
6812
  /** an IANA name, UTC among them, which calendar takes */
6294
6813
  timeZone: [8, str],
6814
+ /** a NaN sample counts in no bucket, which says how many it passed over: skipped */
6815
+ skipNan: [9, bool],
6295
6816
  },
6296
6817
  {
6297
6818
  write(w, v) {
@@ -6343,6 +6864,11 @@ export const MetricsAggregateAsked = message(
6343
6864
  w.str(v.timeZone)
6344
6865
  n++
6345
6866
  }
6867
+ if (v.skipNan !== undefined) {
6868
+ w.field(9)
6869
+ w.bool(v.skipNan)
6870
+ n++
6871
+ }
6346
6872
  w.closeMap(head, n)
6347
6873
  },
6348
6874
  read(r) {
@@ -6354,6 +6880,7 @@ export const MetricsAggregateAsked = message(
6354
6880
  let $estimate: boolean | undefined
6355
6881
  let $calendar: string | undefined
6356
6882
  let $timeZone: string | undefined
6883
+ let $skipNan: boolean | undefined
6357
6884
  for (let n = r.message(); n > 0; n--) {
6358
6885
  switch (r.field()) {
6359
6886
  case 1:
@@ -6392,6 +6919,9 @@ export const MetricsAggregateAsked = message(
6392
6919
  case 8:
6393
6920
  $timeZone = r.str()
6394
6921
  break
6922
+ case 9:
6923
+ $skipNan = r.bool()
6924
+ break
6395
6925
  default:
6396
6926
  r.skip()
6397
6927
  }
@@ -6406,6 +6936,7 @@ export const MetricsAggregateAsked = message(
6406
6936
  estimate: $estimate,
6407
6937
  calendar: $calendar,
6408
6938
  timeZone: $timeZone,
6939
+ skipNan: $skipNan,
6409
6940
  }
6410
6941
  },
6411
6942
  },
@@ -6431,6 +6962,8 @@ export const MetricsBucket = message(
6431
6962
  partial: [8, bool],
6432
6963
  /** its first step began before the bucket before it */
6433
6964
  gap: [9, bool],
6965
+ /** the NaN samples it passed over, with skipNan */
6966
+ skipped: [10, uint],
6434
6967
  },
6435
6968
  {
6436
6969
  write(w, v) {
@@ -6481,6 +7014,11 @@ export const MetricsBucket = message(
6481
7014
  w.bool(v.gap)
6482
7015
  n++
6483
7016
  }
7017
+ if (v.skipped !== undefined) {
7018
+ w.field(10)
7019
+ w.uint(v.skipped)
7020
+ n++
7021
+ }
6484
7022
  w.closeMap(head, n)
6485
7023
  },
6486
7024
  read(r) {
@@ -6493,6 +7031,7 @@ export const MetricsBucket = message(
6493
7031
  let $resets: number | undefined
6494
7032
  let $partial: boolean | undefined
6495
7033
  let $gap: boolean | undefined
7034
+ let $skipped: number | undefined
6496
7035
  for (let n = r.message(); n > 0; n--) {
6497
7036
  switch (r.field()) {
6498
7037
  case 1:
@@ -6522,6 +7061,9 @@ export const MetricsBucket = message(
6522
7061
  case 9:
6523
7062
  $gap = r.bool()
6524
7063
  break
7064
+ case 10:
7065
+ $skipped = r.uint()
7066
+ break
6525
7067
  default:
6526
7068
  r.skip()
6527
7069
  }
@@ -6537,6 +7079,7 @@ export const MetricsBucket = message(
6537
7079
  resets: $resets,
6538
7080
  partial: $partial,
6539
7081
  gap: $gap,
7082
+ skipped: $skipped,
6540
7083
  }
6541
7084
  },
6542
7085
  },
@@ -11158,7 +11701,8 @@ export const SqlMigration = message(
11158
11701
 
11159
11702
  /**
11160
11703
  * Opens a database. Migrations, when given, are applied and checked; without
11161
- * them the file opens as it is.
11704
+ * them the file opens as it is. One that backups leave out lies in local/
11705
+ * rather than sql/, and a name whose file lies in the other folder is invalid.
11162
11706
  */
11163
11707
  export const SqlOpen = message(
11164
11708
  'sql.Open',
@@ -11168,6 +11712,8 @@ export const SqlOpen = message(
11168
11712
  migrations: [2, list(SqlMigration)],
11169
11713
  /** full or os: how far its commits go before they return; the store's own when absent */
11170
11714
  durability: [3, str],
11715
+ /** false: no backup takes it, nor any node; true when absent */
11716
+ backup: [4, bool],
11171
11717
  },
11172
11718
  {
11173
11719
  write(w, v) {
@@ -11191,12 +11737,18 @@ export const SqlOpen = message(
11191
11737
  w.str(v.durability)
11192
11738
  n++
11193
11739
  }
11740
+ if (v.backup !== undefined) {
11741
+ w.field(4)
11742
+ w.bool(v.backup)
11743
+ n++
11744
+ }
11194
11745
  w.closeMap(head, n)
11195
11746
  },
11196
11747
  read(r) {
11197
11748
  let $name: string | undefined
11198
11749
  let $migrations: Read<typeof SqlMigration.fields>[] | undefined
11199
11750
  let $durability: string | undefined
11751
+ let $backup: boolean | undefined
11200
11752
  for (let n = r.message(); n > 0; n--) {
11201
11753
  switch (r.field()) {
11202
11754
  case 1:
@@ -11214,12 +11766,15 @@ export const SqlOpen = message(
11214
11766
  case 3:
11215
11767
  $durability = r.str()
11216
11768
  break
11769
+ case 4:
11770
+ $backup = r.bool()
11771
+ break
11217
11772
  default:
11218
11773
  r.skip()
11219
11774
  }
11220
11775
  }
11221
11776
  r.leave()
11222
- return { name: $name, migrations: $migrations, durability: $durability }
11777
+ return { name: $name, migrations: $migrations, durability: $durability, backup: $backup }
11223
11778
  },
11224
11779
  },
11225
11780
  )
@@ -11370,8 +11925,58 @@ export const SqlStatement = message(
11370
11925
  )
11371
11926
 
11372
11927
  /**
11373
- * What a statement gives back: its rows, one row or none, or one value. A
11374
- * write with returning runs on the writer, its rows given once it is durable.
11928
+ * A column a statement's rows are ordered by, named as its rows name it.
11929
+ */
11930
+ export const SqlOrder = message(
11931
+ 'sql.Order',
11932
+ {
11933
+ column: [1, str],
11934
+ descending: [2, bool],
11935
+ },
11936
+ {
11937
+ write(w, v) {
11938
+ const head = w.openMap()
11939
+ let n = 0
11940
+ if (v.column !== undefined) {
11941
+ w.field(1)
11942
+ w.str(v.column)
11943
+ n++
11944
+ }
11945
+ if (v.descending !== undefined) {
11946
+ w.field(2)
11947
+ w.bool(v.descending)
11948
+ n++
11949
+ }
11950
+ w.closeMap(head, n)
11951
+ },
11952
+ read(r) {
11953
+ let $column: string | undefined
11954
+ let $descending: boolean | undefined
11955
+ for (let n = r.message(); n > 0; n--) {
11956
+ switch (r.field()) {
11957
+ case 1:
11958
+ $column = r.str()
11959
+ break
11960
+ case 2:
11961
+ $descending = r.bool()
11962
+ break
11963
+ default:
11964
+ r.skip()
11965
+ }
11966
+ }
11967
+ r.leave()
11968
+ return { column: $column, descending: $descending }
11969
+ },
11970
+ },
11971
+ )
11972
+
11973
+ /**
11974
+ * What a statement gives back: its rows, one row or none, one value, or each
11975
+ * row as the reader reads it. A write with returning runs on the writer, its
11976
+ * rows given once it is durable. Each reads one snapshot of five seconds at
11977
+ * most; with order, the columns its text orders its rows by, a unique one
11978
+ * last, it reads on past that after the last row it sent, and without it
11979
+ * fails limit there.
11375
11980
  */
11376
11981
  export const SqlQuery = message(
11377
11982
  'sql.Query',
@@ -11379,8 +11984,9 @@ export const SqlQuery = message(
11379
11984
  handle: [1, uint],
11380
11985
  text: [2, str],
11381
11986
  values: [3, list(sqlValue)],
11382
- /** all, one or scalar */
11987
+ /** all, one, scalar or each */
11383
11988
  want: [4, str],
11989
+ order: [5, list(SqlOrder)],
11384
11990
  },
11385
11991
  {
11386
11992
  write(w, v) {
@@ -11409,6 +12015,14 @@ export const SqlQuery = message(
11409
12015
  w.str(v.want)
11410
12016
  n++
11411
12017
  }
12018
+ if (v.order !== undefined) {
12019
+ w.field(5)
12020
+ w.array(v.order.length)
12021
+ for (const item0 of v.order) {
12022
+ SqlOrder.write(w, item0)
12023
+ }
12024
+ n++
12025
+ }
11412
12026
  w.closeMap(head, n)
11413
12027
  },
11414
12028
  read(r) {
@@ -11416,6 +12030,7 @@ export const SqlQuery = message(
11416
12030
  let $text: string | undefined
11417
12031
  let $values: (SqlValue | boolean)[] | undefined
11418
12032
  let $want: string | undefined
12033
+ let $order: Read<typeof SqlOrder.fields>[] | undefined
11419
12034
  for (let n = r.message(); n > 0; n--) {
11420
12035
  switch (r.field()) {
11421
12036
  case 1:
@@ -11436,12 +12051,21 @@ export const SqlQuery = message(
11436
12051
  case 4:
11437
12052
  $want = r.str()
11438
12053
  break
12054
+ case 5: {
12055
+ const items0: Read<typeof SqlOrder.fields>[] = []
12056
+ for (let i0 = r.array(); i0 > 0; i0--) {
12057
+ items0.push(SqlOrder.read(r))
12058
+ }
12059
+ r.leave()
12060
+ $order = items0
12061
+ break
12062
+ }
11439
12063
  default:
11440
12064
  r.skip()
11441
12065
  }
11442
12066
  }
11443
12067
  r.leave()
11444
- return { handle: $handle, text: $text, values: $values, want: $want }
12068
+ return { handle: $handle, text: $text, values: $values, want: $want, order: $order }
11445
12069
  },
11446
12070
  },
11447
12071
  )