Tiny CBOR Schema

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
// COSE EC2 key parameters (aligned with common WebAuthn usage)
4
const Ec2KeyParametersSchema = cs.map([
5
  cs.numberField(1, 'kty', cs.literal(2)),      // Key Type: EC2
6
  cs.numberField(2, 'kid', cs.optional(cs.bytes)),
7
  cs.numberField(3, 'alg', cs.optional(cs.literal(-7))), // ES256
8
  cs.numberField(
9
    4,
10
    'key_ops',
11
    cs.optional(cs.array(cs.union([cs.literal(1), cs.literal(2)]))),
12
  ),
13
  cs.numberField(-1, 'crv', cs.literal(1)),     // P-256
14
  cs.numberField(-2, 'x', cs.bytes),
15
  cs.numberField(-3, 'y', cs.union([cs.bytes, cs.boolean])),
16
  cs.numberField(-4, 'd', cs.optional(cs.bytes)),
17
]);
18
​
19
type Ec2KeyParameters = valueOf<typeof Ec2KeyParametersSchema>
20
​
21
const publicKey: Ec2KeyParameters = {
22
  kty: 2,
23
  alg: -7,
24
  crv: 1,
25
  x: new Uint8Array([1,2,3]),
26
  y: new Uint8Array([4,5,6]),
27
};
28
console.log('publicKey:', publicKey);
29
​
30
const encoded = cs.toCBOR(Ec2KeyParametersSchema, publicKey);
31
console.log('encoded:', encoded);
32
const decoded = cs.fromCBOR(Ec2KeyParametersSchema, encoded); // typed as Ec2KeyParameters
33
console.log('decoded:', decoded);

1
import { cs } from '@levischuck/tiny-cbor-schema'
2
​
3
// Round trip a few values without aliasing primitives
4
const encString = cs.toCBOR(cs.string, 'hello');
5
console.log('encString:', encString);
6
const decString = cs.fromCBOR(cs.string, encString); // 'hello'
7
console.log('decString:', decString);
8
​
9
const encBig = cs.toCBOR(cs.bigint, BigInt('9007199254740992'));
10
console.log('encBig:', encBig);
11
const decBig = cs.fromCBOR(cs.bigint, encBig);
12
console.log('decBig:', decBig);
13
​
14
const xCoord = new Uint8Array([1,2,3]);
15
console.log('xCoord:', xCoord);
16
const encBytes = cs.toCBOR(cs.bytes, xCoord);
17
console.log('encBytes:', encBytes);
18
const decBytes = cs.fromCBOR(cs.bytes, encBytes);
19
console.log('decBytes:', decBytes);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
const numbers = cs.array(cs.integer);
4
type Numbers = valueOf<typeof numbers>; // number[]
5
​
6
const encoded = cs.toCBOR(numbers, [1,2,3]);
7
console.log('encoded:', encoded);
8
const decoded = cs.fromCBOR(numbers, encoded); // [1,2,3]
9
console.log('decoded:', decoded);
10
​
11
const pointSchema = cs.tuple([cs.float, cs.float]);
12
type Point = valueOf<typeof pointSchema>; // [number, number]
13
​
14
const p = cs.fromCBOR(pointSchema, cs.toCBOR(pointSchema, [10.5, 20.7]));
15
console.log('p:', p);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
const cwtClaims = cs.map([
4
  cs.numberField(1, 'iss', cs.string),     // issuer (numeric key)
5
  cs.numberField(4, 'exp', cs.integer),    // expiration time
6
  cs.numberField(7, 'cti', cs.bytes),      // CWT ID
7
  cs.field('cty', cs.optional(cs.string)), // string-keyed field
8
]);
9
​
10
type CWT = valueOf<typeof cwtClaims>;
11
​
12
const claims: CWT = {
13
  iss: 'example-issuer',
14
  exp: 1_725_000_000,
15
  cti: new Uint8Array([1,2,3]),
16
};
17
console.log('claims:', claims);
18
​
19
const encoded = cs.toCBOR(cwtClaims, claims);
20
console.log('encoded:', encoded);
21
const decoded = cs.fromCBOR(cwtClaims, encoded) as CWT;
22
console.log('decoded:', decoded);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
const maybeNumber = cs.optional(cs.float);
4
type MaybeNumber = valueOf<typeof maybeNumber>; // number | undefined
5
​
6
const status = cs.literal('ok');
7
type Status = valueOf<typeof status>; // 'ok'
8
​
9
const enc1 = cs.toCBOR(maybeNumber, 42);
10
console.log('enc1:', enc1);
11
const dec1 = cs.fromCBOR(maybeNumber, enc1); // 42
12
console.log('dec1:', dec1);
13
const enc2 = cs.toCBOR(maybeNumber, undefined);
14
console.log('enc2:', enc2);
15
const dec2 = cs.fromCBOR(maybeNumber, enc2); // undefined
16
console.log('dec2:', dec2);
17
​
18
const enc3 = cs.toCBOR(status, 'ok');
19
console.log('enc3:', enc3);
20
const dec3 = cs.fromCBOR(status, enc3); // 'ok'
21
console.log('dec3:', dec3);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
const numberOrString = cs.union([cs.float, cs.string]);
4
type NumberOrString = valueOf<typeof numberOrString>; // number | string
5
​
6
const encA = cs.toCBOR(numberOrString, 42);
7
console.log('encA:', encA);
8
const decA = cs.fromCBOR(numberOrString, encA); // 42
9
console.log('decA:', decA);
10
const encB = cs.toCBOR(numberOrString, 'hello');
11
console.log('encB:', encB);
12
const decB = cs.fromCBOR(numberOrString, encB); // 'hello'
13
console.log('decB:', decB);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
// Tag 0 is standard datetime string in CBOR registry
4
const dateTime = cs.tagged(0, cs.string);
5
type DateTime = valueOf<typeof dateTime>; // { tag: 0, value: string }
6
​
7
const now: DateTime = { tag: 0, value: new Date().toISOString() };
8
console.log('now:', now);
9
const enc = cs.toCBOR(dateTime, now);
10
console.log('enc:', enc);
11
const dec = cs.fromCBOR(dateTime, enc); // preserves tag and value
12
console.log('dec:', dec);

1
import { cs } from '@levischuck/tiny-cbor-schema'
2
​
3
const meta = cs.map([
4
  cs.field('version', cs.integer),
5
]);
6
​
7
const document = cs.map([
8
  cs.field('content', cs.string),
9
  cs.field('metadata', cs.nested(meta)),
10
]);
11
​
12
const encoded = cs.toCBOR(document, { content: 'Hello', metadata: { version: 1 } });
13
console.log('encoded:', encoded);
14
const decoded = cs.fromCBOR(document, encoded);
15
console.log('decoded:', decoded);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
type Tree = { value: string; children: Tree[] };
4
let treeSchema: any;
5
treeSchema = cs.map([
6
  cs.field('value', cs.string),
7
  cs.field('children', cs.array(cs.lazy(() => treeSchema)))
8
]);
9
​
10
type TreeValue = valueOf<typeof treeSchema>; // Tree
11
​
12
const tree: Tree = { value: 'root', children: [{ value: 'leaf', children: [] }] };
13
console.log('tree:', tree);
14
const enc = cs.toCBOR(treeSchema, tree);
15
console.log('enc:', enc);
16
const dec = cs.fromCBOR(treeSchema, enc);
17
console.log('dec:', dec);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
const ec2KeyParametersSchema = cs.map([
4
  cs.numberField(1, 'kty', cs.literal(2)),
5
  cs.numberField(3, 'alg', cs.literal(-7)),
6
  cs.numberField(-1, 'crv', cs.literal(1)),
7
  cs.numberField(-2, 'x', cs.bytes),
8
  cs.numberField(-3, 'y', cs.bytes),
9
]);
10
type Ec2KeyParameters = valueOf<typeof ec2KeyParametersSchema>;
11
​
12
const key: Ec2KeyParameters = {
13
  kty: 2,
14
  alg: -7,
15
  crv: 1,
16
  x: new Uint8Array([/* x coord */]),
17
  y: new Uint8Array([/* y coord */]),
18
};
19
console.log('key:', key);
20
const coseBytes = cs.toCBOR(ec2KeyParametersSchema, key);
21
console.log('coseBytes:', coseBytes);
22
const parsedKey = cs.fromCBOR(ec2KeyParametersSchema, coseBytes);
23
console.log('parsedKey:', parsedKey);

1
import { cs, type valueOf } from '@levischuck/tiny-cbor-schema'
2
​
3
const cwtClaims = cs.map([
4
  cs.numberField(1, 'iss', cs.string),     // Issuer
5
  cs.numberField(4, 'exp', cs.integer),    // Expiration time
6
  cs.numberField(7, 'cti', cs.bytes),      // CWT ID
7
]);
8
type CWT = valueOf<typeof cwtClaims>;
9
​
10
const claims: CWT = {
11
  iss: 'example-issuer',
12
  exp: 1_725_000_000,
13
  cti: new Uint8Array([0x01, 0x02, 0x03]),
14
};
15
console.log('claims:', claims);
16
const cwtBytes = cs.toCBOR(cwtClaims, claims);
17
console.log('cwtBytes:', cwtBytes);
18
const parsedClaims = cs.fromCBOR(cwtClaims, cwtBytes);
19
console.log('parsedClaims:', parsedClaims);