Commit f4002fb9 authored by Janka Uryga's avatar Janka Uryga

tagged serialization format

parent 5a224361
import { lengthEncodeTuple, lengthDecodeTuple } from './length-encoding'
import {
lengthEncodeTuple,
lengthDecodeTuple,
lengthEncodeTupleWithTag,
lengthDecodeTupleWithTag,
type TaggedStringTuple,
} from './length-encoding'
const cases: { description: string; input: string[] }[] = [
[],
......@@ -32,3 +38,23 @@ it.each(cases)(
expect(decoded).toEqual(input)
}
)
enum MyTag {
A = 0,
B = 1,
C = 9,
}
describe('tags', () => {
describe.each([MyTag.A, MyTag.B, MyTag.C])('tag value - %d', (tag) => {
it.each(cases)(
'can encode and decode tuples with a tag without changes - $description',
({ input: inputWithoutTag }) => {
const input: TaggedStringTuple = [tag, ...inputWithoutTag]
const encoded: string = lengthEncodeTupleWithTag(input)
const decoded: TaggedStringTuple = lengthDecodeTupleWithTag(encoded)
expect(decoded).toEqual(input)
}
)
})
})
......@@ -93,3 +93,41 @@ export function lengthDecodeTuple(encoded: string): string[] {
return parts
}
export type TaggedStringTuple = [tag: number, ...rest: string[]]
/**
* Encodes a tuple of strings into a single string,
* where each part except the last is prefixed with its length.
* */
export function lengthEncodeTupleWithTag([tag, ...rest]: TaggedStringTuple) {
// Technically, we could allow more by using letters, but we don't need that now.
if (tag < 0 || tag > 9) {
throw new InvariantError(
'Tags that cannot be encoded as a single digit are not supported'
)
}
return tag + lengthEncodeTuple(rest)
}
const ASCII_0 = '0'.charCodeAt(0)
const ASCII_9 = '9'.charCodeAt(0)
export function lengthDecodeTupleWithTag(encoded: string): TaggedStringTuple {
if (!encoded) {
throw new InvariantError('Expected tag but got empty input')
}
// The tag is a single ASCII digit.
const tagCharCode = encoded.charCodeAt(0)
if (tagCharCode < ASCII_0 || tagCharCode > ASCII_9) {
throw new InvariantError(
`Expected tag to be a numeric digit, but got '${encoded[0]}'`
)
}
const tag = tagCharCode - ASCII_0
const parts = lengthDecodeTuple(encoded.slice(1)) as (string | number)[]
parts.unshift(tag)
return parts as TaggedStringTuple
}
......@@ -8,7 +8,10 @@ import {
type RenderResumeDataCache,
} from '../resume-data-cache/resume-data-cache'
import { stringifyResumeDataCache } from '../resume-data-cache/resume-data-cache'
import { lengthDecodeTuple, lengthEncodeTuple } from './length-encoding'
import {
lengthDecodeTupleWithTag,
lengthEncodeTupleWithTag,
} from './length-encoding'
export enum DynamicState {
/**
......@@ -73,17 +76,39 @@ export type PostponedState =
| DynamicDataPostponedState
| DynamicHTMLPostponedState
function serializeStateParts(state: SerializedStateParts) {
return lengthEncodeTupleWithTag(state)
}
function deserializeStateParts(serialized: string) {
return lengthDecodeTupleWithTag(serialized) as SerializedStateParts
}
type SerializedStateParts =
| SerializedDynamicData
| SerializedDynamicHTML
| SerializedDynamicHTMLWithReplacements
type SerializedDynamicData = [resumeDataCache: string]
type SerializedDynamicHTML = [postponed: string, resumeDataCache: string]
type SerializedDynamicHTMLWithReplacements = [
replacements: string,
enum SerializedStateTag {
DynamicData = 0,
DynamicHTML = 1,
DynamicHTMLWithReplacements = 2,
}
type SerializedDynamicData = [
tag: SerializedStateTag.DynamicData,
resumeDataCache: string,
]
type SerializedDynamicHTML = [
tag: SerializedStateTag.DynamicHTML,
resumeDataCache: string,
postponed: string,
]
type SerializedDynamicHTMLWithReplacements = [
tag: SerializedStateTag.DynamicHTMLWithReplacements,
resumeDataCache: string,
postponed: string,
replacements: string,
]
export async function getDynamicHTMLPostponedState(
......@@ -96,32 +121,35 @@ export async function getDynamicHTMLPostponedState(
const dataString = JSON.stringify(data)
if (!fallbackRouteParams || fallbackRouteParams.size === 0) {
return lengthEncodeTuple([
dataString,
return serializeStateParts([
SerializedStateTag.DynamicHTML,
await stringifyResumeDataCache(
createRenderResumeDataCache(resumeDataCache)
),
] satisfies SerializedDynamicHTML)
dataString,
])
}
const replacements: Array<[string, string]> = Array.from(fallbackRouteParams)
const replacementsString = JSON.stringify(replacements)
return lengthEncodeTuple([
replacementsString,
dataString,
return serializeStateParts([
SerializedStateTag.DynamicHTMLWithReplacements,
await stringifyResumeDataCache(resumeDataCache),
] satisfies SerializedDynamicHTMLWithReplacements)
dataString,
replacementsString,
])
}
export async function getDynamicDataPostponedState(
resumeDataCache: PrerenderResumeDataCache | RenderResumeDataCache
): Promise<string> {
return lengthEncodeTuple([
return serializeStateParts([
SerializedStateTag.DynamicData,
await stringifyResumeDataCache(
createRenderResumeDataCache(resumeDataCache)
),
] satisfies SerializedDynamicData)
])
}
export function parsePostponedState(
......@@ -129,61 +157,59 @@ export function parsePostponedState(
params: Params | undefined
): PostponedState {
try {
const parts = lengthDecodeTuple(state) as SerializedStateParts
if (parts.length === 1) {
parts satisfies SerializedDynamicData
const [resumeDataCacheString] = parts
const renderResumeDataCache = createRenderResumeDataCache(
resumeDataCacheString
)
return {
type: DynamicState.DATA,
renderResumeDataCache,
}
} else if (parts.length === 2 || parts.length === 3) {
let replacementsString: string | null = null,
postponedString: string,
resumeDataCacheString: string
if (parts.length === 2) {
parts satisfies SerializedDynamicHTML
;[postponedString, resumeDataCacheString] = parts
} else {
parts satisfies SerializedDynamicHTMLWithReplacements
;[replacementsString, postponedString, resumeDataCacheString] = parts
const parts = deserializeStateParts(state)
const tag = parts[0]
switch (tag) {
case SerializedStateTag.DynamicData: {
const [, resumeDataCacheString] = parts
const renderResumeDataCache = createRenderResumeDataCache(
resumeDataCacheString
)
return {
type: DynamicState.DATA,
renderResumeDataCache,
}
}
const renderResumeDataCache = createRenderResumeDataCache(
resumeDataCacheString
)
try {
if (replacementsString !== null) {
const replacements = JSON.parse(replacementsString) as ReadonlyArray<
[string, string]
>
for (const [key, searchValue] of replacements) {
const value = params?.[key] ?? ''
const replaceValue = Array.isArray(value) ? value.join('/') : value
postponedString = postponedString.replaceAll(
searchValue,
replaceValue
)
case SerializedStateTag.DynamicHTML:
case SerializedStateTag.DynamicHTMLWithReplacements: {
// These two variants mostly overlap, except for the last element
let [, resumeDataCacheString, postponedString] = parts
const renderResumeDataCache = createRenderResumeDataCache(
resumeDataCacheString
)
try {
if (tag === SerializedStateTag.DynamicHTMLWithReplacements) {
const replacementsString = parts[3]
const replacements = JSON.parse(
replacementsString
) as ReadonlyArray<[string, string]>
for (const [key, searchValue] of replacements) {
const value = params?.[key] ?? ''
const replaceValue = Array.isArray(value)
? value.join('/')
: value
postponedString = postponedString.replaceAll(
searchValue,
replaceValue
)
}
}
}
return {
type: DynamicState.HTML,
data: JSON.parse(postponedString),
renderResumeDataCache,
return {
type: DynamicState.HTML,
data: JSON.parse(postponedString),
renderResumeDataCache,
}
} catch (err) {
console.error('Failed to parse postponed state', err)
return { type: DynamicState.DATA, renderResumeDataCache }
}
} catch (err) {
console.error('Failed to parse postponed state', err)
return { type: DynamicState.DATA, renderResumeDataCache }
}
} else {
parts satisfies never
throw new InvariantError('Postponed state tuple has invalid length')
default: {
parts satisfies never
throw new InvariantError(`Invalid postponed state tag: ${tag}`)
}
}
} catch (err) {
console.error('Failed to parse postponed state', err)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment