From d5253b9be8b4edce31eb4412ffcadb8aba538428 Mon Sep 17 00:00:00 2001 From: Fern Sanchez Date: Tue, 12 May 2026 17:53:20 -0400 Subject: [PATCH] fix: remove unsafe-eval form typescript sdk --- .../src/lib/algebraic_type.ts | 340 +- .../src/lib/autogen/types.ts | 3624 ++++++++++++++--- .../src/lib/type_builders.ts | 36 +- .../src/sdk/client_api/index.ts | 11 +- .../src/sdk/client_api/types.ts | 1240 +++++- crates/bindings-typescript/src/sdk/ws.ts | 16 +- crates/cli/src/subcommands/generate.rs | 29 +- crates/codegen/src/typescript.rs | 500 ++- .../codegen__codegen_typescript.snap | 624 ++- 9 files changed, 5380 insertions(+), 1040 deletions(-) diff --git a/crates/bindings-typescript/src/lib/algebraic_type.ts b/crates/bindings-typescript/src/lib/algebraic_type.ts index c325797af75..a086f3f6aa4 100644 --- a/crates/bindings-typescript/src/lib/algebraic_type.ts +++ b/crates/bindings-typescript/src/lib/algebraic_type.ts @@ -78,14 +78,42 @@ export type Serializer = (writer: BinaryWriter, value: T) => void; export type Deserializer = (reader: BinaryReader) => T; // Caches to prevent `makeSerializer`/`makeDeserializer` from recursing -// infinitely when called on recursive types. +// infinitely when called on recursive types, and to allow codegen to +// pre-register static serializers/deserializers for named compound types so +// they don't have to be built at runtime via a tree walker. // // We check for recursion in `{Product,Sum}Type.make{Deser,Ser}ializer` rather // than in `AlgebraciType.make{Deser,Ser}ializer` because we need to store the // [de]serializer in the cache before recursing into its fields/variants, and // we wouldn't be able to do that in the `AlgebraicType` functions. -const SERIALIZERS = new Map>(); -const DESERIALIZERS = new Map>(); +export const SERIALIZERS = new Map< + ProductType | SumType, + Serializer +>(); +export const DESERIALIZERS = new Map< + ProductType | SumType, + Deserializer +>(); + +/** + * Register a static serializer/deserializer for a `Product` or `Sum` + * algebraic type, so that future calls to + * {@link AlgebraicType.makeSerializer}/{@link AlgebraicType.makeDeserializer} + * (and the corresponding `ProductType`/`SumType` variants) return the + * provided functions instead of building closures at runtime. + * + * This is intended for use by code generation, which knows the full structure + * of every emitted type and can produce static, inlined (de)serialization + * functions ahead of time. + */ +export function registerSerde( + ty: ProductType | SumType, + serializer: Serializer, + deserializer: Deserializer +): void { + SERIALIZERS.set(ty, serializer); + DESERIALIZERS.set(ty, deserializer); +} // A value with helper functions to construct the type. export const AlgebraicType = { @@ -300,62 +328,6 @@ Object.freeze(primitiveDeserializers); const deserializeUint8Array = bindCall(BinaryReader.prototype.readUInt8Array); -type FixedSizePrimitives = Exclude; - -const primitiveSizes: Record = { - Bool: 1, - I8: 1, - U8: 1, - I16: 2, - U16: 2, - I32: 4, - U32: 4, - I64: 8, - U64: 8, - I128: 16, - U128: 16, - I256: 32, - U256: 32, - F32: 4, - F64: 8, -}; - -const fixedSizePrimitives = new Set(Object.keys(primitiveSizes)); - -type FixedSizeProductType = { - elements: { name: string; algebraicType: { tag: FixedSizePrimitives } }[]; -}; - -const isFixedSizeProduct = (ty: ProductType): ty is FixedSizeProductType => - ty.elements.every(({ algebraicType }) => - fixedSizePrimitives.has(algebraicType.tag) - ); - -const productSize = (ty: FixedSizeProductType): number => - ty.elements.reduce( - (acc, { algebraicType }) => acc + primitiveSizes[algebraicType.tag], - 0 - ); - -type JSPrimitives = Exclude< - FixedSizePrimitives, - 'I128' | 'U128' | 'I256' | 'U256' ->; - -const primitiveJSName: Record = { - Bool: 'Uint8', - I8: 'Int8', - U8: 'Uint8', - I16: 'Int16', - U16: 'Uint16', - I32: 'Int32', - U32: 'Uint32', - I64: 'BigInt64', - U64: 'BigUint64', - F32: 'Float32', - F64: 'Float64', -}; - type SpecialProducts = { __time_duration_micros__: TimeDuration; __timestamp_micros_since_unix_epoch__: Timestamp; @@ -378,41 +350,6 @@ Object.freeze(specialProductDeserializers); const unitDeserializer: Deserializer<{}> = () => ({}); -const getElementInitializer = (element: ProductTypeElement) => { - let init: string; - switch (element.algebraicType.tag) { - case 'String': - init = "''"; - break; - case 'Bool': - init = 'false'; - break; - case 'I8': - case 'U8': - case 'I16': - case 'U16': - case 'I32': - case 'U32': - init = '0'; - break; - case 'I64': - case 'U64': - case 'I128': - case 'U128': - case 'I256': - case 'U256': - init = '0n'; - break; - case 'F32': - case 'F64': - init = '0.0'; - break; - default: - init = 'undefined'; - } - return `${element.name!}: ${init}`; -}; - /** * A structural product type of the factors given by `elements`. * @@ -448,55 +385,23 @@ export const ProductType = { let serializer = SERIALIZERS.get(ty); if (serializer != null) return serializer; - if (isFixedSizeProduct(ty)) { - const size = productSize(ty); - const body = `\ -"use strict"; -writer.expandBuffer(${size}); -const view = writer.view; -${ty.elements - .map(({ name, algebraicType: { tag } }) => - tag in primitiveJSName - ? `\ -view.set${primitiveJSName[tag as JSPrimitives]}(writer.offset, value.${name!}, ${primitiveSizes[tag] > 1 ? 'true' : ''}); -writer.offset += ${primitiveSizes[tag]};` - : `writer.write${tag}(value.${name});` - ) - .join('\n')}`; - serializer = Function('writer', 'value', body) as Serializer; - SERIALIZERS.set(ty, serializer); - return serializer; - } - - // Because V8 forces us to generate our code as a string, rather than a proper syntax tree, - // we can't have our `body` close over values. - // Instead, we construct an object with the values we'd otherwise "close over" in `serializers`, - // and use `Function.prototype.bind` to pass it as the `this` argument. - // - // We populate `serializers` after constructing this type's `serializer` - // so that it can close over itself, in the case that `ty` is recursive. - const serializers: Record> = {}; - const body = - '"use strict";\n' + - ty.elements - .map( - element => `this.${element.name!}(writer, value.${element.name!});` - ) - .join('\n'); - serializer = Function('writer', 'value', body).bind( - serializers - ) as Serializer; - // In case `ty` is recursive, we cache the function *before* before computing - // `serializers`, so that a recursive `makeSerializer` with the same `ty` has - // an exit condition. + // We populate `fieldNames`/`fieldSerializers` after caching the closure + // so that it can recursively reference itself for recursive types. + const fieldNames: string[] = []; + const fieldSerializers: Serializer[] = []; + const numFields = ty.elements.length; + serializer = (writer, value) => { + for (let i = 0; i < numFields; i++) { + fieldSerializers[i](writer, value[fieldNames[i]]); + } + }; SERIALIZERS.set(ty, serializer); for (const { name, algebraicType } of ty.elements) { - serializers[name!] = AlgebraicType.makeSerializer( - algebraicType, - typespace + fieldNames.push(name!); + fieldSerializers.push( + AlgebraicType.makeSerializer(algebraicType, typespace) ); } - Object.freeze(serializers); return serializer; }, /** @deprecated Use `makeSerializer` instead. */ @@ -527,57 +432,25 @@ writer.offset += ${primitiveSizes[tag]};` let deserializer = DESERIALIZERS.get(ty); if (deserializer != null) return deserializer; - if (isFixedSizeProduct(ty)) { - const body = `\ -"use strict"; -const result = { ${ty.elements.map(getElementInitializer).join(', ')} }; -const view = reader.view; -${ty.elements - .map(({ name, algebraicType: { tag } }) => - tag in primitiveJSName - ? tag === 'Bool' - ? `\ -result.${name} = view.getUint8(reader.offset) !== 0; -reader.offset += 1;` - : `\ -result.${name} = view.get${primitiveJSName[tag as JSPrimitives]}(reader.offset, ${primitiveSizes[tag] > 1 ? 'true' : ''}); -reader.offset += ${primitiveSizes[tag]};` - : `result.${name} = reader.read${tag}();` - ) - .join('\n')} -return result;`; - deserializer = Function('reader', body) as Deserializer; - DESERIALIZERS.set(ty, deserializer); - return deserializer; - } - - // Because V8 forces us to generate our code as a string, rather than a proper syntax tree, - // we can't have our `body` close over values. - // Instead, we construct an object with the values we'd otherwise "close over" in `deserializers`, - // and use `Function.prototype.bind` to pass it as the `this` argument. - // - // We populate `deserializers` after constructing this type's `deserializer` - // so that it can close over itself, in the case that `ty` is recursive. - const deserializers: Record> = {}; - deserializer = Function( - 'reader', - `\ -"use strict"; -const result = { ${ty.elements.map(getElementInitializer).join(', ')} }; -${ty.elements.map(({ name }) => `result.${name!} = this.${name!}(reader);`).join('\n')} -return result;` - ).bind(deserializers) as Deserializer; - // In case `ty` is recursive, we cache the function *before* before computing - // `deserializers`, so that a recursive `makeDeserializer` with the same `ty` has - // an exit condition. + // We populate `fieldNames`/`fieldDeserializers` after caching the closure + // so that it can recursively reference itself for recursive types. + const fieldNames: string[] = []; + const fieldDeserializers: Deserializer[] = []; + const numFields = ty.elements.length; + deserializer = reader => { + const result: any = {}; + for (let i = 0; i < numFields; i++) { + result[fieldNames[i]] = fieldDeserializers[i](reader); + } + return result; + }; DESERIALIZERS.set(ty, deserializer); for (const { name, algebraicType } of ty.elements) { - deserializers[name!] = AlgebraicType.makeDeserializer( - algebraicType, - typespace + fieldNames.push(name!); + fieldDeserializers.push( + AlgebraicType.makeDeserializer(algebraicType, typespace) ); } - Object.freeze(deserializers); return deserializer; }, /** @deprecated Use `makeDeserializer` instead. */ @@ -678,41 +551,30 @@ export const SumType = { let serializer = SERIALIZERS.get(ty); if (serializer != null) return serializer; - const serializers: Record> = {}; - - const body = `\ -switch (value.tag) { -${ty.variants - .map( - ({ name }, i) => `\ - case ${JSON.stringify(name!)}: - writer.writeByte(${i}); - return this.${name!}(writer, value.value);` - ) - .join('\n')} - default: - throw new TypeError( - \`Could not serialize sum type; unknown tag \${value.tag}\` - ) -} -`; - - serializer = Function('writer', 'value', body).bind( - serializers - ) as Serializer; - - // In case `ty` is recursive, we cache the function *before* before computing - // `variants`, so that a recursive `makeSerializer` with the same `ty` has - // an exit condition. + // Map of tag name -> { index, serialize } for O(1) dispatch on `value.tag`. + // Populated after caching the closure so that recursive types can + // reference themselves through the cache. + const variantSerializers: Record< + string, + { index: number; serialize: Serializer } + > = Object.create(null); + serializer = (writer, value) => { + const variant = variantSerializers[value.tag]; + if (variant === undefined) { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + writer.writeByte(variant.index); + variant.serialize(writer, value.value); + }; SERIALIZERS.set(ty, serializer); - - for (const { name, algebraicType } of ty.variants) { - serializers[name!] = AlgebraicType.makeSerializer( - algebraicType, - typespace - ); - } - Object.freeze(serializers); + ty.variants.forEach(({ name, algebraicType }, i) => { + variantSerializers[name!] = { + index: i, + serialize: AlgebraicType.makeSerializer(algebraicType, typespace), + }; + }); return serializer; } }, @@ -782,27 +644,31 @@ ${ty.variants } else { let deserializer = DESERIALIZERS.get(ty); if (deserializer != null) return deserializer; - const deserializers: Record> = {}; - deserializer = Function( - 'reader', - `switch (reader.readU8()) {\n${ty.variants - .map( - ({ name }, i) => - `case ${i}: return { tag: ${JSON.stringify(name!)}, value: this.${name!}(reader) };` - ) - .join('\n')} }` - ).bind(deserializers) as Deserializer; - // In case `ty` is recursive, we cache the function *before* before computing - // `deserializers`, so that a recursive `makeDeserializer` with the same `ty` has - // an exit condition. + // Parallel arrays of variant names and their deserializers, indexed by + // wire tag. Populated after caching so recursive types resolve through + // the cache. + const variantNames: string[] = []; + const variantDeserializers: Deserializer[] = []; + const numVariants = ty.variants.length; + deserializer = reader => { + const tag = reader.readU8(); + if (tag >= numVariants) { + // Preserve original behavior: out-of-range tags return undefined + // (the prior `switch`-based implementation simply fell through). + return undefined; + } + return { + tag: variantNames[tag], + value: variantDeserializers[tag](reader), + }; + }; DESERIALIZERS.set(ty, deserializer); for (const { name, algebraicType } of ty.variants) { - deserializers[name!] = AlgebraicType.makeDeserializer( - algebraicType, - typespace + variantNames.push(name!); + variantDeserializers.push( + AlgebraicType.makeDeserializer(algebraicType, typespace) ); } - Object.freeze(deserializers); return deserializer; } }, diff --git a/crates/bindings-typescript/src/lib/autogen/types.ts b/crates/bindings-typescript/src/lib/autogen/types.ts index 0ce535eca0f..c3a45c13204 100644 --- a/crates/bindings-typescript/src/lib/autogen/types.ts +++ b/crates/bindings-typescript/src/lib/autogen/types.ts @@ -4,7 +4,12 @@ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -14,695 +19,3234 @@ import { export const AlgebraicType: __TypeBuilder< __AlgebraicTypeType, __AlgebraicTypeType -> = __t.enum('AlgebraicType', { - Ref: __t.u32(), - get Sum() { - return SumType; - }, - get Product() { - return ProductType; - }, - get Array() { - return AlgebraicType; - }, - String: __t.unit(), - Bool: __t.unit(), - I8: __t.unit(), - U8: __t.unit(), - I16: __t.unit(), - U16: __t.unit(), - I32: __t.unit(), - U32: __t.unit(), - I64: __t.unit(), - U64: __t.unit(), - I128: __t.unit(), - U128: __t.unit(), - I256: __t.unit(), - U256: __t.unit(), - F32: __t.unit(), - F64: __t.unit(), -}); +> = __t + .enum('AlgebraicType', { + Ref: __t.u32(), + get Sum() { + return SumType; + }, + get Product() { + return ProductType; + }, + get Array() { + return AlgebraicType; + }, + String: __t.unit(), + Bool: __t.unit(), + I8: __t.unit(), + U8: __t.unit(), + I16: __t.unit(), + U16: __t.unit(), + I32: __t.unit(), + U32: __t.unit(), + I64: __t.unit(), + U64: __t.unit(), + I128: __t.unit(), + U128: __t.unit(), + I256: __t.unit(), + U256: __t.unit(), + F32: __t.unit(), + F64: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Ref': { + writer.writeByte(0); + writer.writeU32(value.value); + break; + } + case 'Sum': { + writer.writeByte(1); + SumType.serialize(writer, value.value); + break; + } + case 'Product': { + writer.writeByte(2); + ProductType.serialize(writer, value.value); + break; + } + case 'Array': { + writer.writeByte(3); + AlgebraicType.serialize(writer, value.value); + break; + } + case 'String': { + writer.writeByte(4); + break; + } + case 'Bool': { + writer.writeByte(5); + break; + } + case 'I8': { + writer.writeByte(6); + break; + } + case 'U8': { + writer.writeByte(7); + break; + } + case 'I16': { + writer.writeByte(8); + break; + } + case 'U16': { + writer.writeByte(9); + break; + } + case 'I32': { + writer.writeByte(10); + break; + } + case 'U32': { + writer.writeByte(11); + break; + } + case 'I64': { + writer.writeByte(12); + break; + } + case 'U64': { + writer.writeByte(13); + break; + } + case 'I128': { + writer.writeByte(14); + break; + } + case 'U128': { + writer.writeByte(15); + break; + } + case 'I256': { + writer.writeByte(16); + break; + } + case 'U256': { + writer.writeByte(17); + break; + } + case 'F32': { + writer.writeByte(18); + break; + } + case 'F64': { + writer.writeByte(19); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = reader.readU32(); + return { tag: 'Ref', value: __v }; + } + case 1: { + let __v: any; + __v = SumType.deserialize(reader); + return { tag: 'Sum', value: __v }; + } + case 2: { + let __v: any; + __v = ProductType.deserialize(reader); + return { tag: 'Product', value: __v }; + } + case 3: { + let __v: any; + __v = AlgebraicType.deserialize(reader); + return { tag: 'Array', value: __v }; + } + case 4: { + return { tag: 'String', value: {} }; + } + case 5: { + return { tag: 'Bool', value: {} }; + } + case 6: { + return { tag: 'I8', value: {} }; + } + case 7: { + return { tag: 'U8', value: {} }; + } + case 8: { + return { tag: 'I16', value: {} }; + } + case 9: { + return { tag: 'U16', value: {} }; + } + case 10: { + return { tag: 'I32', value: {} }; + } + case 11: { + return { tag: 'U32', value: {} }; + } + case 12: { + return { tag: 'I64', value: {} }; + } + case 13: { + return { tag: 'U64', value: {} }; + } + case 14: { + return { tag: 'I128', value: {} }; + } + case 15: { + return { tag: 'U128', value: {} }; + } + case 16: { + return { tag: 'I256', value: {} }; + } + case 17: { + return { tag: 'U256', value: {} }; + } + case 18: { + return { tag: 'F32', value: {} }; + } + case 19: { + return { tag: 'F64', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type AlgebraicType = __Infer; // The tagged union or sum type for the algebraic type `CaseConversionPolicy`. -export const CaseConversionPolicy = __t.enum('CaseConversionPolicy', { - None: __t.unit(), - SnakeCase: __t.unit(), -}); +export const CaseConversionPolicy = __t + .enum('CaseConversionPolicy', { + None: __t.unit(), + SnakeCase: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'None': { + writer.writeByte(0); + break; + } + case 'SnakeCase': { + writer.writeByte(1); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'None', value: {} }; + } + case 1: { + return { tag: 'SnakeCase', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type CaseConversionPolicy = __Infer; // The tagged union or sum type for the algebraic type `ExplicitNameEntry`. -export const ExplicitNameEntry = __t.enum('ExplicitNameEntry', { - get Table() { - return NameMapping; - }, - get Function() { - return NameMapping; - }, - get Index() { - return NameMapping; - }, -}); +export const ExplicitNameEntry = __t + .enum('ExplicitNameEntry', { + get Table() { + return NameMapping; + }, + get Function() { + return NameMapping; + }, + get Index() { + return NameMapping; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Table': { + writer.writeByte(0); + NameMapping.serialize(writer, value.value); + break; + } + case 'Function': { + writer.writeByte(1); + NameMapping.serialize(writer, value.value); + break; + } + case 'Index': { + writer.writeByte(2); + NameMapping.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = NameMapping.deserialize(reader); + return { tag: 'Table', value: __v }; + } + case 1: { + let __v: any; + __v = NameMapping.deserialize(reader); + return { tag: 'Function', value: __v }; + } + case 2: { + let __v: any; + __v = NameMapping.deserialize(reader); + return { tag: 'Index', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type ExplicitNameEntry = __Infer; -export const ExplicitNames = __t.object('ExplicitNames', { - get entries() { - return __t.array(ExplicitNameEntry); - }, -}); +export const ExplicitNames = __t + .object('ExplicitNames', { + get entries() { + return __t.array(ExplicitNameEntry); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.entries.length); + for (const __e0 of value.entries) { + ExplicitNameEntry.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = ExplicitNameEntry.deserialize(reader); + } + __f0 = __arr0; + } + return { entries: __f0 }; + } + ); export type ExplicitNames = __Infer; // The tagged union or sum type for the algebraic type `FunctionVisibility`. -export const FunctionVisibility = __t.enum('FunctionVisibility', { - Private: __t.unit(), - ClientCallable: __t.unit(), -}); +export const FunctionVisibility = __t + .enum('FunctionVisibility', { + Private: __t.unit(), + ClientCallable: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Private': { + writer.writeByte(0); + break; + } + case 'ClientCallable': { + writer.writeByte(1); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'Private', value: {} }; + } + case 1: { + return { tag: 'ClientCallable', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type FunctionVisibility = __Infer; -export const HttpHeaderPair = __t.object('HttpHeaderPair', { - name: __t.string(), - value: __t.byteArray(), -}); +export const HttpHeaderPair = __t + .object('HttpHeaderPair', { + name: __t.string(), + value: __t.byteArray(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + writer.writeUInt8Array(value.value); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readUInt8Array(); + return { name: __f0, value: __f1 }; + } + ); export type HttpHeaderPair = __Infer; -export const HttpHeaders = __t.object('HttpHeaders', { - get entries() { - return __t.array(HttpHeaderPair); - }, -}); +export const HttpHeaders = __t + .object('HttpHeaders', { + get entries() { + return __t.array(HttpHeaderPair); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.entries.length); + for (const __e0 of value.entries) { + HttpHeaderPair.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = HttpHeaderPair.deserialize(reader); + } + __f0 = __arr0; + } + return { entries: __f0 }; + } + ); export type HttpHeaders = __Infer; // The tagged union or sum type for the algebraic type `HttpMethod`. -export const HttpMethod = __t.enum('HttpMethod', { - Get: __t.unit(), - Head: __t.unit(), - Post: __t.unit(), - Put: __t.unit(), - Delete: __t.unit(), - Connect: __t.unit(), - Options: __t.unit(), - Trace: __t.unit(), - Patch: __t.unit(), - Extension: __t.string(), -}); +export const HttpMethod = __t + .enum('HttpMethod', { + Get: __t.unit(), + Head: __t.unit(), + Post: __t.unit(), + Put: __t.unit(), + Delete: __t.unit(), + Connect: __t.unit(), + Options: __t.unit(), + Trace: __t.unit(), + Patch: __t.unit(), + Extension: __t.string(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Get': { + writer.writeByte(0); + break; + } + case 'Head': { + writer.writeByte(1); + break; + } + case 'Post': { + writer.writeByte(2); + break; + } + case 'Put': { + writer.writeByte(3); + break; + } + case 'Delete': { + writer.writeByte(4); + break; + } + case 'Connect': { + writer.writeByte(5); + break; + } + case 'Options': { + writer.writeByte(6); + break; + } + case 'Trace': { + writer.writeByte(7); + break; + } + case 'Patch': { + writer.writeByte(8); + break; + } + case 'Extension': { + writer.writeByte(9); + writer.writeString(value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'Get', value: {} }; + } + case 1: { + return { tag: 'Head', value: {} }; + } + case 2: { + return { tag: 'Post', value: {} }; + } + case 3: { + return { tag: 'Put', value: {} }; + } + case 4: { + return { tag: 'Delete', value: {} }; + } + case 5: { + return { tag: 'Connect', value: {} }; + } + case 6: { + return { tag: 'Options', value: {} }; + } + case 7: { + return { tag: 'Trace', value: {} }; + } + case 8: { + return { tag: 'Patch', value: {} }; + } + case 9: { + let __v: any; + __v = reader.readString(); + return { tag: 'Extension', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type HttpMethod = __Infer; -export const HttpRequest = __t.object('HttpRequest', { - get method() { - return HttpMethod; - }, - get headers() { - return HttpHeaders; - }, - timeout: __t.option(__t.timeDuration()), - uri: __t.string(), - get version() { - return HttpVersion; - }, -}); +export const HttpRequest = __t + .object('HttpRequest', { + get method() { + return HttpMethod; + }, + get headers() { + return HttpHeaders; + }, + timeout: __t.option(__t.timeDuration()), + uri: __t.string(), + get version() { + return HttpVersion; + }, + }) + .withSerde( + (writer, value: any) => { + HttpMethod.serialize(writer, value.method); + HttpHeaders.serialize(writer, value.headers); + if (value.timeout === undefined || value.timeout === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI64(value.timeout.__time_duration_micros__); + } + writer.writeString(value.uri); + HttpVersion.serialize(writer, value.version); + }, + (reader): any => { + let __f0: any; + __f0 = HttpMethod.deserialize(reader); + let __f1: any; + __f1 = HttpHeaders.deserialize(reader); + let __f2: any; + if (reader.readByte() === 0) { + __f2 = new __TimeDuration(reader.readI64()); + } else { + __f2 = undefined; + } + let __f3: any; + __f3 = reader.readString(); + let __f4: any; + __f4 = HttpVersion.deserialize(reader); + return { + method: __f0, + headers: __f1, + timeout: __f2, + uri: __f3, + version: __f4, + }; + } + ); export type HttpRequest = __Infer; -export const HttpResponse = __t.object('HttpResponse', { - get headers() { - return HttpHeaders; - }, - get version() { - return HttpVersion; - }, - code: __t.u16(), -}); +export const HttpResponse = __t + .object('HttpResponse', { + get headers() { + return HttpHeaders; + }, + get version() { + return HttpVersion; + }, + code: __t.u16(), + }) + .withSerde( + (writer, value: any) => { + HttpHeaders.serialize(writer, value.headers); + HttpVersion.serialize(writer, value.version); + writer.writeU16(value.code); + }, + (reader): any => { + let __f0: any; + __f0 = HttpHeaders.deserialize(reader); + let __f1: any; + __f1 = HttpVersion.deserialize(reader); + let __f2: any; + __f2 = reader.readU16(); + return { headers: __f0, version: __f1, code: __f2 }; + } + ); export type HttpResponse = __Infer; // The tagged union or sum type for the algebraic type `HttpVersion`. -export const HttpVersion = __t.enum('HttpVersion', { - Http09: __t.unit(), - Http10: __t.unit(), - Http11: __t.unit(), - Http2: __t.unit(), - Http3: __t.unit(), -}); +export const HttpVersion = __t + .enum('HttpVersion', { + Http09: __t.unit(), + Http10: __t.unit(), + Http11: __t.unit(), + Http2: __t.unit(), + Http3: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Http09': { + writer.writeByte(0); + break; + } + case 'Http10': { + writer.writeByte(1); + break; + } + case 'Http11': { + writer.writeByte(2); + break; + } + case 'Http2': { + writer.writeByte(3); + break; + } + case 'Http3': { + writer.writeByte(4); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'Http09', value: {} }; + } + case 1: { + return { tag: 'Http10', value: {} }; + } + case 2: { + return { tag: 'Http11', value: {} }; + } + case 3: { + return { tag: 'Http2', value: {} }; + } + case 4: { + return { tag: 'Http3', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type HttpVersion = __Infer; // The tagged union or sum type for the algebraic type `IndexType`. -export const IndexType = __t.enum('IndexType', { - BTree: __t.unit(), - Hash: __t.unit(), -}); +export const IndexType = __t + .enum('IndexType', { + BTree: __t.unit(), + Hash: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'BTree': { + writer.writeByte(0); + break; + } + case 'Hash': { + writer.writeByte(1); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'BTree', value: {} }; + } + case 1: { + return { tag: 'Hash', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type IndexType = __Infer; // The tagged union or sum type for the algebraic type `Lifecycle`. -export const Lifecycle = __t.enum('Lifecycle', { - Init: __t.unit(), - OnConnect: __t.unit(), - OnDisconnect: __t.unit(), -}); +export const Lifecycle = __t + .enum('Lifecycle', { + Init: __t.unit(), + OnConnect: __t.unit(), + OnDisconnect: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Init': { + writer.writeByte(0); + break; + } + case 'OnConnect': { + writer.writeByte(1); + break; + } + case 'OnDisconnect': { + writer.writeByte(2); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'Init', value: {} }; + } + case 1: { + return { tag: 'OnConnect', value: {} }; + } + case 2: { + return { tag: 'OnDisconnect', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type Lifecycle = __Infer; // The tagged union or sum type for the algebraic type `MiscModuleExport`. -export const MiscModuleExport = __t.enum('MiscModuleExport', { - get TypeAlias() { - return TypeAlias; - }, -}); +export const MiscModuleExport = __t + .enum('MiscModuleExport', { + get TypeAlias() { + return TypeAlias; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'TypeAlias': { + writer.writeByte(0); + TypeAlias.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = TypeAlias.deserialize(reader); + return { tag: 'TypeAlias', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type MiscModuleExport = __Infer; -export const NameMapping = __t.object('NameMapping', { - sourceName: __t.string(), - canonicalName: __t.string(), -}); +export const NameMapping = __t + .object('NameMapping', { + sourceName: __t.string(), + canonicalName: __t.string(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sourceName); + writer.writeString(value.canonicalName); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readString(); + return { sourceName: __f0, canonicalName: __f1 }; + } + ); export type NameMapping = __Infer; -export const ProductType = __t.object('ProductType', { - get elements() { - return __t.array(ProductTypeElement); - }, -}); +export const ProductType = __t + .object('ProductType', { + get elements() { + return __t.array(ProductTypeElement); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.elements.length); + for (const __e0 of value.elements) { + ProductTypeElement.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = ProductTypeElement.deserialize(reader); + } + __f0 = __arr0; + } + return { elements: __f0 }; + } + ); export type ProductType = __Infer; -export const ProductTypeElement = __t.object('ProductTypeElement', { - name: __t.option(__t.string()), - get algebraicType() { - return AlgebraicType; - }, -}); +export const ProductTypeElement = __t + .object('ProductTypeElement', { + name: __t.option(__t.string()), + get algebraicType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + if (value.name === undefined || value.name === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.name); + } + AlgebraicType.serialize(writer, value.algebraicType); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = AlgebraicType.deserialize(reader); + return { name: __f0, algebraicType: __f1 }; + } + ); export type ProductTypeElement = __Infer; -export const RawColumnDefV8 = __t.object('RawColumnDefV8', { - colName: __t.string(), - get colType() { - return AlgebraicType; - }, -}); +export const RawColumnDefV8 = __t + .object('RawColumnDefV8', { + colName: __t.string(), + get colType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.colName); + AlgebraicType.serialize(writer, value.colType); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = AlgebraicType.deserialize(reader); + return { colName: __f0, colType: __f1 }; + } + ); export type RawColumnDefV8 = __Infer; -export const RawColumnDefaultValueV10 = __t.object('RawColumnDefaultValueV10', { - colId: __t.u16(), - value: __t.byteArray(), -}); +export const RawColumnDefaultValueV10 = __t + .object('RawColumnDefaultValueV10', { + colId: __t.u16(), + value: __t.byteArray(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU16(value.colId); + writer.writeUInt8Array(value.value); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU16(); + let __f1: any; + __f1 = reader.readUInt8Array(); + return { colId: __f0, value: __f1 }; + } + ); export type RawColumnDefaultValueV10 = __Infer; -export const RawColumnDefaultValueV9 = __t.object('RawColumnDefaultValueV9', { - table: __t.string(), - colId: __t.u16(), - value: __t.byteArray(), -}); +export const RawColumnDefaultValueV9 = __t + .object('RawColumnDefaultValueV9', { + table: __t.string(), + colId: __t.u16(), + value: __t.byteArray(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.table); + writer.writeU16(value.colId); + writer.writeUInt8Array(value.value); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU16(); + let __f2: any; + __f2 = reader.readUInt8Array(); + return { table: __f0, colId: __f1, value: __f2 }; + } + ); export type RawColumnDefaultValueV9 = __Infer; // The tagged union or sum type for the algebraic type `RawConstraintDataV9`. -export const RawConstraintDataV9 = __t.enum('RawConstraintDataV9', { - get Unique() { - return RawUniqueConstraintDataV9; - }, -}); +export const RawConstraintDataV9 = __t + .enum('RawConstraintDataV9', { + get Unique() { + return RawUniqueConstraintDataV9; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Unique': { + writer.writeByte(0); + RawUniqueConstraintDataV9.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = RawUniqueConstraintDataV9.deserialize(reader); + return { tag: 'Unique', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type RawConstraintDataV9 = __Infer; -export const RawConstraintDefV10 = __t.object('RawConstraintDefV10', { - sourceName: __t.option(__t.string()), - get data() { - return RawConstraintDataV9; - }, -}); +export const RawConstraintDefV10 = __t + .object('RawConstraintDefV10', { + sourceName: __t.option(__t.string()), + get data() { + return RawConstraintDataV9; + }, + }) + .withSerde( + (writer, value: any) => { + if (value.sourceName === undefined || value.sourceName === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.sourceName); + } + RawConstraintDataV9.serialize(writer, value.data); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = RawConstraintDataV9.deserialize(reader); + return { sourceName: __f0, data: __f1 }; + } + ); export type RawConstraintDefV10 = __Infer; -export const RawConstraintDefV8 = __t.object('RawConstraintDefV8', { - constraintName: __t.string(), - constraints: __t.u8(), - columns: __t.array(__t.u16()), -}); +export const RawConstraintDefV8 = __t + .object('RawConstraintDefV8', { + constraintName: __t.string(), + constraints: __t.u8(), + columns: __t.array(__t.u16()), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.constraintName); + writer.writeU8(value.constraints); + writer.writeU32(value.columns.length); + for (const __e0 of value.columns) { + writer.writeU16(__e0); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU8(); + let __f2: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU16(); + } + __f2 = __arr0; + } + return { constraintName: __f0, constraints: __f1, columns: __f2 }; + } + ); export type RawConstraintDefV8 = __Infer; -export const RawConstraintDefV9 = __t.object('RawConstraintDefV9', { - name: __t.option(__t.string()), - get data() { - return RawConstraintDataV9; - }, -}); +export const RawConstraintDefV9 = __t + .object('RawConstraintDefV9', { + name: __t.option(__t.string()), + get data() { + return RawConstraintDataV9; + }, + }) + .withSerde( + (writer, value: any) => { + if (value.name === undefined || value.name === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.name); + } + RawConstraintDataV9.serialize(writer, value.data); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = RawConstraintDataV9.deserialize(reader); + return { name: __f0, data: __f1 }; + } + ); export type RawConstraintDefV9 = __Infer; // The tagged union or sum type for the algebraic type `RawIndexAlgorithm`. -export const RawIndexAlgorithm = __t.enum('RawIndexAlgorithm', { - BTree: __t.array(__t.u16()), - Hash: __t.array(__t.u16()), - Direct: __t.u16(), -}); +export const RawIndexAlgorithm = __t + .enum('RawIndexAlgorithm', { + BTree: __t.array(__t.u16()), + Hash: __t.array(__t.u16()), + Direct: __t.u16(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'BTree': { + writer.writeByte(0); + writer.writeU32(value.value.length); + for (const __e0 of value.value) { + writer.writeU16(__e0); + } + break; + } + case 'Hash': { + writer.writeByte(1); + writer.writeU32(value.value.length); + for (const __e1 of value.value) { + writer.writeU16(__e1); + } + break; + } + case 'Direct': { + writer.writeByte(2); + writer.writeU16(value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU16(); + } + __v = __arr0; + } + return { tag: 'BTree', value: __v }; + } + case 1: { + let __v: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = reader.readU16(); + } + __v = __arr1; + } + return { tag: 'Hash', value: __v }; + } + case 2: { + let __v: any; + __v = reader.readU16(); + return { tag: 'Direct', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type RawIndexAlgorithm = __Infer; -export const RawIndexDefV10 = __t.object('RawIndexDefV10', { - sourceName: __t.option(__t.string()), - accessorName: __t.option(__t.string()), - get algorithm() { - return RawIndexAlgorithm; - }, -}); +export const RawIndexDefV10 = __t + .object('RawIndexDefV10', { + sourceName: __t.option(__t.string()), + accessorName: __t.option(__t.string()), + get algorithm() { + return RawIndexAlgorithm; + }, + }) + .withSerde( + (writer, value: any) => { + if (value.sourceName === undefined || value.sourceName === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.sourceName); + } + if (value.accessorName === undefined || value.accessorName === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.accessorName); + } + RawIndexAlgorithm.serialize(writer, value.algorithm); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + if (reader.readByte() === 0) { + __f1 = reader.readString(); + } else { + __f1 = undefined; + } + let __f2: any; + __f2 = RawIndexAlgorithm.deserialize(reader); + return { sourceName: __f0, accessorName: __f1, algorithm: __f2 }; + } + ); export type RawIndexDefV10 = __Infer; -export const RawIndexDefV8 = __t.object('RawIndexDefV8', { - indexName: __t.string(), - isUnique: __t.bool(), - get indexType() { - return IndexType; - }, - columns: __t.array(__t.u16()), -}); +export const RawIndexDefV8 = __t + .object('RawIndexDefV8', { + indexName: __t.string(), + isUnique: __t.bool(), + get indexType() { + return IndexType; + }, + columns: __t.array(__t.u16()), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.indexName); + writer.writeBool(value.isUnique); + IndexType.serialize(writer, value.indexType); + writer.writeU32(value.columns.length); + for (const __e0 of value.columns) { + writer.writeU16(__e0); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readBool(); + let __f2: any; + __f2 = IndexType.deserialize(reader); + let __f3: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU16(); + } + __f3 = __arr0; + } + return { + indexName: __f0, + isUnique: __f1, + indexType: __f2, + columns: __f3, + }; + } + ); export type RawIndexDefV8 = __Infer; -export const RawIndexDefV9 = __t.object('RawIndexDefV9', { - name: __t.option(__t.string()), - accessorName: __t.option(__t.string()), - get algorithm() { - return RawIndexAlgorithm; - }, -}); +export const RawIndexDefV9 = __t + .object('RawIndexDefV9', { + name: __t.option(__t.string()), + accessorName: __t.option(__t.string()), + get algorithm() { + return RawIndexAlgorithm; + }, + }) + .withSerde( + (writer, value: any) => { + if (value.name === undefined || value.name === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.name); + } + if (value.accessorName === undefined || value.accessorName === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.accessorName); + } + RawIndexAlgorithm.serialize(writer, value.algorithm); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + if (reader.readByte() === 0) { + __f1 = reader.readString(); + } else { + __f1 = undefined; + } + let __f2: any; + __f2 = RawIndexAlgorithm.deserialize(reader); + return { name: __f0, accessorName: __f1, algorithm: __f2 }; + } + ); export type RawIndexDefV9 = __Infer; -export const RawLifeCycleReducerDefV10 = __t.object( - 'RawLifeCycleReducerDefV10', - { +export const RawLifeCycleReducerDefV10 = __t + .object('RawLifeCycleReducerDefV10', { get lifecycleSpec() { return Lifecycle; }, functionName: __t.string(), - } -); + }) + .withSerde( + (writer, value: any) => { + Lifecycle.serialize(writer, value.lifecycleSpec); + writer.writeString(value.functionName); + }, + (reader): any => { + let __f0: any; + __f0 = Lifecycle.deserialize(reader); + let __f1: any; + __f1 = reader.readString(); + return { lifecycleSpec: __f0, functionName: __f1 }; + } + ); export type RawLifeCycleReducerDefV10 = __Infer< typeof RawLifeCycleReducerDefV10 >; // The tagged union or sum type for the algebraic type `RawMiscModuleExportV9`. -export const RawMiscModuleExportV9 = __t.enum('RawMiscModuleExportV9', { - get ColumnDefaultValue() { - return RawColumnDefaultValueV9; - }, - get Procedure() { - return RawProcedureDefV9; - }, - get View() { - return RawViewDefV9; - }, -}); +export const RawMiscModuleExportV9 = __t + .enum('RawMiscModuleExportV9', { + get ColumnDefaultValue() { + return RawColumnDefaultValueV9; + }, + get Procedure() { + return RawProcedureDefV9; + }, + get View() { + return RawViewDefV9; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'ColumnDefaultValue': { + writer.writeByte(0); + RawColumnDefaultValueV9.serialize(writer, value.value); + break; + } + case 'Procedure': { + writer.writeByte(1); + RawProcedureDefV9.serialize(writer, value.value); + break; + } + case 'View': { + writer.writeByte(2); + RawViewDefV9.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = RawColumnDefaultValueV9.deserialize(reader); + return { tag: 'ColumnDefaultValue', value: __v }; + } + case 1: { + let __v: any; + __v = RawProcedureDefV9.deserialize(reader); + return { tag: 'Procedure', value: __v }; + } + case 2: { + let __v: any; + __v = RawViewDefV9.deserialize(reader); + return { tag: 'View', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type RawMiscModuleExportV9 = __Infer; // The tagged union or sum type for the algebraic type `RawModuleDef`. -export const RawModuleDef = __t.enum('RawModuleDef', { - get V8BackCompat() { - return RawModuleDefV8; - }, - get V9() { - return RawModuleDefV9; - }, - get V10() { - return RawModuleDefV10; - }, -}); +export const RawModuleDef = __t + .enum('RawModuleDef', { + get V8BackCompat() { + return RawModuleDefV8; + }, + get V9() { + return RawModuleDefV9; + }, + get V10() { + return RawModuleDefV10; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'V8BackCompat': { + writer.writeByte(0); + RawModuleDefV8.serialize(writer, value.value); + break; + } + case 'V9': { + writer.writeByte(1); + RawModuleDefV9.serialize(writer, value.value); + break; + } + case 'V10': { + writer.writeByte(2); + RawModuleDefV10.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = RawModuleDefV8.deserialize(reader); + return { tag: 'V8BackCompat', value: __v }; + } + case 1: { + let __v: any; + __v = RawModuleDefV9.deserialize(reader); + return { tag: 'V9', value: __v }; + } + case 2: { + let __v: any; + __v = RawModuleDefV10.deserialize(reader); + return { tag: 'V10', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type RawModuleDef = __Infer; -export const RawModuleDefV10 = __t.object('RawModuleDefV10', { - get sections() { - return __t.array(RawModuleDefV10Section); - }, -}); +export const RawModuleDefV10 = __t + .object('RawModuleDefV10', { + get sections() { + return __t.array(RawModuleDefV10Section); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.sections.length); + for (const __e0 of value.sections) { + RawModuleDefV10Section.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = RawModuleDefV10Section.deserialize(reader); + } + __f0 = __arr0; + } + return { sections: __f0 }; + } + ); export type RawModuleDefV10 = __Infer; // The tagged union or sum type for the algebraic type `RawModuleDefV10Section`. -export const RawModuleDefV10Section = __t.enum('RawModuleDefV10Section', { - get Typespace() { - return Typespace; - }, - get Types() { - return __t.array(RawTypeDefV10); - }, - get Tables() { - return __t.array(RawTableDefV10); - }, - get Reducers() { - return __t.array(RawReducerDefV10); - }, - get Procedures() { - return __t.array(RawProcedureDefV10); - }, - get Views() { - return __t.array(RawViewDefV10); - }, - get Schedules() { - return __t.array(RawScheduleDefV10); - }, - get LifeCycleReducers() { - return __t.array(RawLifeCycleReducerDefV10); - }, - get RowLevelSecurity() { - return __t.array(RawRowLevelSecurityDefV9); - }, - get CaseConversionPolicy() { - return CaseConversionPolicy; - }, - get ExplicitNames() { - return ExplicitNames; - }, -}); +export const RawModuleDefV10Section = __t + .enum('RawModuleDefV10Section', { + get Typespace() { + return Typespace; + }, + get Types() { + return __t.array(RawTypeDefV10); + }, + get Tables() { + return __t.array(RawTableDefV10); + }, + get Reducers() { + return __t.array(RawReducerDefV10); + }, + get Procedures() { + return __t.array(RawProcedureDefV10); + }, + get Views() { + return __t.array(RawViewDefV10); + }, + get Schedules() { + return __t.array(RawScheduleDefV10); + }, + get LifeCycleReducers() { + return __t.array(RawLifeCycleReducerDefV10); + }, + get RowLevelSecurity() { + return __t.array(RawRowLevelSecurityDefV9); + }, + get CaseConversionPolicy() { + return CaseConversionPolicy; + }, + get ExplicitNames() { + return ExplicitNames; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Typespace': { + writer.writeByte(0); + Typespace.serialize(writer, value.value); + break; + } + case 'Types': { + writer.writeByte(1); + writer.writeU32(value.value.length); + for (const __e0 of value.value) { + RawTypeDefV10.serialize(writer, __e0); + } + break; + } + case 'Tables': { + writer.writeByte(2); + writer.writeU32(value.value.length); + for (const __e1 of value.value) { + RawTableDefV10.serialize(writer, __e1); + } + break; + } + case 'Reducers': { + writer.writeByte(3); + writer.writeU32(value.value.length); + for (const __e2 of value.value) { + RawReducerDefV10.serialize(writer, __e2); + } + break; + } + case 'Procedures': { + writer.writeByte(4); + writer.writeU32(value.value.length); + for (const __e3 of value.value) { + RawProcedureDefV10.serialize(writer, __e3); + } + break; + } + case 'Views': { + writer.writeByte(5); + writer.writeU32(value.value.length); + for (const __e4 of value.value) { + RawViewDefV10.serialize(writer, __e4); + } + break; + } + case 'Schedules': { + writer.writeByte(6); + writer.writeU32(value.value.length); + for (const __e5 of value.value) { + RawScheduleDefV10.serialize(writer, __e5); + } + break; + } + case 'LifeCycleReducers': { + writer.writeByte(7); + writer.writeU32(value.value.length); + for (const __e6 of value.value) { + RawLifeCycleReducerDefV10.serialize(writer, __e6); + } + break; + } + case 'RowLevelSecurity': { + writer.writeByte(8); + writer.writeU32(value.value.length); + for (const __e7 of value.value) { + RawRowLevelSecurityDefV9.serialize(writer, __e7); + } + break; + } + case 'CaseConversionPolicy': { + writer.writeByte(9); + CaseConversionPolicy.serialize(writer, value.value); + break; + } + case 'ExplicitNames': { + writer.writeByte(10); + ExplicitNames.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = Typespace.deserialize(reader); + return { tag: 'Typespace', value: __v }; + } + case 1: { + let __v: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = RawTypeDefV10.deserialize(reader); + } + __v = __arr0; + } + return { tag: 'Types', value: __v }; + } + case 2: { + let __v: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = RawTableDefV10.deserialize(reader); + } + __v = __arr1; + } + return { tag: 'Tables', value: __v }; + } + case 3: { + let __v: any; + { + const __len2 = reader.readU32(); + const __arr2: any[] = new Array(__len2); + for (let __i2 = 0; __i2 < __len2; __i2++) { + __arr2[__i2] = RawReducerDefV10.deserialize(reader); + } + __v = __arr2; + } + return { tag: 'Reducers', value: __v }; + } + case 4: { + let __v: any; + { + const __len3 = reader.readU32(); + const __arr3: any[] = new Array(__len3); + for (let __i3 = 0; __i3 < __len3; __i3++) { + __arr3[__i3] = RawProcedureDefV10.deserialize(reader); + } + __v = __arr3; + } + return { tag: 'Procedures', value: __v }; + } + case 5: { + let __v: any; + { + const __len4 = reader.readU32(); + const __arr4: any[] = new Array(__len4); + for (let __i4 = 0; __i4 < __len4; __i4++) { + __arr4[__i4] = RawViewDefV10.deserialize(reader); + } + __v = __arr4; + } + return { tag: 'Views', value: __v }; + } + case 6: { + let __v: any; + { + const __len5 = reader.readU32(); + const __arr5: any[] = new Array(__len5); + for (let __i5 = 0; __i5 < __len5; __i5++) { + __arr5[__i5] = RawScheduleDefV10.deserialize(reader); + } + __v = __arr5; + } + return { tag: 'Schedules', value: __v }; + } + case 7: { + let __v: any; + { + const __len6 = reader.readU32(); + const __arr6: any[] = new Array(__len6); + for (let __i6 = 0; __i6 < __len6; __i6++) { + __arr6[__i6] = RawLifeCycleReducerDefV10.deserialize(reader); + } + __v = __arr6; + } + return { tag: 'LifeCycleReducers', value: __v }; + } + case 8: { + let __v: any; + { + const __len7 = reader.readU32(); + const __arr7: any[] = new Array(__len7); + for (let __i7 = 0; __i7 < __len7; __i7++) { + __arr7[__i7] = RawRowLevelSecurityDefV9.deserialize(reader); + } + __v = __arr7; + } + return { tag: 'RowLevelSecurity', value: __v }; + } + case 9: { + let __v: any; + __v = CaseConversionPolicy.deserialize(reader); + return { tag: 'CaseConversionPolicy', value: __v }; + } + case 10: { + let __v: any; + __v = ExplicitNames.deserialize(reader); + return { tag: 'ExplicitNames', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type RawModuleDefV10Section = __Infer; -export const RawModuleDefV8 = __t.object('RawModuleDefV8', { - get typespace() { - return Typespace; - }, - get tables() { - return __t.array(TableDesc); - }, - get reducers() { - return __t.array(ReducerDef); - }, - get miscExports() { - return __t.array(MiscModuleExport); - }, -}); +export const RawModuleDefV8 = __t + .object('RawModuleDefV8', { + get typespace() { + return Typespace; + }, + get tables() { + return __t.array(TableDesc); + }, + get reducers() { + return __t.array(ReducerDef); + }, + get miscExports() { + return __t.array(MiscModuleExport); + }, + }) + .withSerde( + (writer, value: any) => { + Typespace.serialize(writer, value.typespace); + writer.writeU32(value.tables.length); + for (const __e0 of value.tables) { + TableDesc.serialize(writer, __e0); + } + writer.writeU32(value.reducers.length); + for (const __e1 of value.reducers) { + ReducerDef.serialize(writer, __e1); + } + writer.writeU32(value.miscExports.length); + for (const __e2 of value.miscExports) { + MiscModuleExport.serialize(writer, __e2); + } + }, + (reader): any => { + let __f0: any; + __f0 = Typespace.deserialize(reader); + let __f1: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = TableDesc.deserialize(reader); + } + __f1 = __arr0; + } + let __f2: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = ReducerDef.deserialize(reader); + } + __f2 = __arr1; + } + let __f3: any; + { + const __len2 = reader.readU32(); + const __arr2: any[] = new Array(__len2); + for (let __i2 = 0; __i2 < __len2; __i2++) { + __arr2[__i2] = MiscModuleExport.deserialize(reader); + } + __f3 = __arr2; + } + return { + typespace: __f0, + tables: __f1, + reducers: __f2, + miscExports: __f3, + }; + } + ); export type RawModuleDefV8 = __Infer; -export const RawModuleDefV9 = __t.object('RawModuleDefV9', { - get typespace() { - return Typespace; - }, - get tables() { - return __t.array(RawTableDefV9); - }, - get reducers() { - return __t.array(RawReducerDefV9); - }, - get types() { - return __t.array(RawTypeDefV9); - }, - get miscExports() { - return __t.array(RawMiscModuleExportV9); - }, - get rowLevelSecurity() { - return __t.array(RawRowLevelSecurityDefV9); - }, -}); +export const RawModuleDefV9 = __t + .object('RawModuleDefV9', { + get typespace() { + return Typespace; + }, + get tables() { + return __t.array(RawTableDefV9); + }, + get reducers() { + return __t.array(RawReducerDefV9); + }, + get types() { + return __t.array(RawTypeDefV9); + }, + get miscExports() { + return __t.array(RawMiscModuleExportV9); + }, + get rowLevelSecurity() { + return __t.array(RawRowLevelSecurityDefV9); + }, + }) + .withSerde( + (writer, value: any) => { + Typespace.serialize(writer, value.typespace); + writer.writeU32(value.tables.length); + for (const __e0 of value.tables) { + RawTableDefV9.serialize(writer, __e0); + } + writer.writeU32(value.reducers.length); + for (const __e1 of value.reducers) { + RawReducerDefV9.serialize(writer, __e1); + } + writer.writeU32(value.types.length); + for (const __e2 of value.types) { + RawTypeDefV9.serialize(writer, __e2); + } + writer.writeU32(value.miscExports.length); + for (const __e3 of value.miscExports) { + RawMiscModuleExportV9.serialize(writer, __e3); + } + writer.writeU32(value.rowLevelSecurity.length); + for (const __e4 of value.rowLevelSecurity) { + RawRowLevelSecurityDefV9.serialize(writer, __e4); + } + }, + (reader): any => { + let __f0: any; + __f0 = Typespace.deserialize(reader); + let __f1: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = RawTableDefV9.deserialize(reader); + } + __f1 = __arr0; + } + let __f2: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = RawReducerDefV9.deserialize(reader); + } + __f2 = __arr1; + } + let __f3: any; + { + const __len2 = reader.readU32(); + const __arr2: any[] = new Array(__len2); + for (let __i2 = 0; __i2 < __len2; __i2++) { + __arr2[__i2] = RawTypeDefV9.deserialize(reader); + } + __f3 = __arr2; + } + let __f4: any; + { + const __len3 = reader.readU32(); + const __arr3: any[] = new Array(__len3); + for (let __i3 = 0; __i3 < __len3; __i3++) { + __arr3[__i3] = RawMiscModuleExportV9.deserialize(reader); + } + __f4 = __arr3; + } + let __f5: any; + { + const __len4 = reader.readU32(); + const __arr4: any[] = new Array(__len4); + for (let __i4 = 0; __i4 < __len4; __i4++) { + __arr4[__i4] = RawRowLevelSecurityDefV9.deserialize(reader); + } + __f5 = __arr4; + } + return { + typespace: __f0, + tables: __f1, + reducers: __f2, + types: __f3, + miscExports: __f4, + rowLevelSecurity: __f5, + }; + } + ); export type RawModuleDefV9 = __Infer; -export const RawProcedureDefV10 = __t.object('RawProcedureDefV10', { - sourceName: __t.string(), - get params() { - return ProductType; - }, - get returnType() { - return AlgebraicType; - }, - get visibility() { - return FunctionVisibility; - }, -}); +export const RawProcedureDefV10 = __t + .object('RawProcedureDefV10', { + sourceName: __t.string(), + get params() { + return ProductType; + }, + get returnType() { + return AlgebraicType; + }, + get visibility() { + return FunctionVisibility; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sourceName); + ProductType.serialize(writer, value.params); + AlgebraicType.serialize(writer, value.returnType); + FunctionVisibility.serialize(writer, value.visibility); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = ProductType.deserialize(reader); + let __f2: any; + __f2 = AlgebraicType.deserialize(reader); + let __f3: any; + __f3 = FunctionVisibility.deserialize(reader); + return { + sourceName: __f0, + params: __f1, + returnType: __f2, + visibility: __f3, + }; + } + ); export type RawProcedureDefV10 = __Infer; -export const RawProcedureDefV9 = __t.object('RawProcedureDefV9', { - name: __t.string(), - get params() { - return ProductType; - }, - get returnType() { - return AlgebraicType; - }, -}); +export const RawProcedureDefV9 = __t + .object('RawProcedureDefV9', { + name: __t.string(), + get params() { + return ProductType; + }, + get returnType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + ProductType.serialize(writer, value.params); + AlgebraicType.serialize(writer, value.returnType); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = ProductType.deserialize(reader); + let __f2: any; + __f2 = AlgebraicType.deserialize(reader); + return { name: __f0, params: __f1, returnType: __f2 }; + } + ); export type RawProcedureDefV9 = __Infer; -export const RawReducerDefV10 = __t.object('RawReducerDefV10', { - sourceName: __t.string(), - get params() { - return ProductType; - }, - get visibility() { - return FunctionVisibility; - }, - get okReturnType() { - return AlgebraicType; - }, - get errReturnType() { - return AlgebraicType; - }, -}); +export const RawReducerDefV10 = __t + .object('RawReducerDefV10', { + sourceName: __t.string(), + get params() { + return ProductType; + }, + get visibility() { + return FunctionVisibility; + }, + get okReturnType() { + return AlgebraicType; + }, + get errReturnType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sourceName); + ProductType.serialize(writer, value.params); + FunctionVisibility.serialize(writer, value.visibility); + AlgebraicType.serialize(writer, value.okReturnType); + AlgebraicType.serialize(writer, value.errReturnType); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = ProductType.deserialize(reader); + let __f2: any; + __f2 = FunctionVisibility.deserialize(reader); + let __f3: any; + __f3 = AlgebraicType.deserialize(reader); + let __f4: any; + __f4 = AlgebraicType.deserialize(reader); + return { + sourceName: __f0, + params: __f1, + visibility: __f2, + okReturnType: __f3, + errReturnType: __f4, + }; + } + ); export type RawReducerDefV10 = __Infer; -export const RawReducerDefV9 = __t.object('RawReducerDefV9', { - name: __t.string(), - get params() { - return ProductType; - }, - get lifecycle() { - return __t.option(Lifecycle); - }, -}); +export const RawReducerDefV9 = __t + .object('RawReducerDefV9', { + name: __t.string(), + get params() { + return ProductType; + }, + get lifecycle() { + return __t.option(Lifecycle); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + ProductType.serialize(writer, value.params); + if (value.lifecycle === undefined || value.lifecycle === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + Lifecycle.serialize(writer, value.lifecycle); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = ProductType.deserialize(reader); + let __f2: any; + if (reader.readByte() === 0) { + __f2 = Lifecycle.deserialize(reader); + } else { + __f2 = undefined; + } + return { name: __f0, params: __f1, lifecycle: __f2 }; + } + ); export type RawReducerDefV9 = __Infer; -export const RawRowLevelSecurityDefV9 = __t.object('RawRowLevelSecurityDefV9', { - sql: __t.string(), -}); +export const RawRowLevelSecurityDefV9 = __t + .object('RawRowLevelSecurityDefV9', { + sql: __t.string(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sql); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + return { sql: __f0 }; + } + ); export type RawRowLevelSecurityDefV9 = __Infer; -export const RawScheduleDefV10 = __t.object('RawScheduleDefV10', { - sourceName: __t.option(__t.string()), - tableName: __t.string(), - scheduleAtCol: __t.u16(), - functionName: __t.string(), -}); +export const RawScheduleDefV10 = __t + .object('RawScheduleDefV10', { + sourceName: __t.option(__t.string()), + tableName: __t.string(), + scheduleAtCol: __t.u16(), + functionName: __t.string(), + }) + .withSerde( + (writer, value: any) => { + if (value.sourceName === undefined || value.sourceName === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.sourceName); + } + writer.writeString(value.tableName); + writer.writeU16(value.scheduleAtCol); + writer.writeString(value.functionName); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = reader.readString(); + let __f2: any; + __f2 = reader.readU16(); + let __f3: any; + __f3 = reader.readString(); + return { + sourceName: __f0, + tableName: __f1, + scheduleAtCol: __f2, + functionName: __f3, + }; + } + ); export type RawScheduleDefV10 = __Infer; -export const RawScheduleDefV9 = __t.object('RawScheduleDefV9', { - name: __t.option(__t.string()), - reducerName: __t.string(), - scheduledAtColumn: __t.u16(), -}); +export const RawScheduleDefV9 = __t + .object('RawScheduleDefV9', { + name: __t.option(__t.string()), + reducerName: __t.string(), + scheduledAtColumn: __t.u16(), + }) + .withSerde( + (writer, value: any) => { + if (value.name === undefined || value.name === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.name); + } + writer.writeString(value.reducerName); + writer.writeU16(value.scheduledAtColumn); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = reader.readString(); + let __f2: any; + __f2 = reader.readU16(); + return { name: __f0, reducerName: __f1, scheduledAtColumn: __f2 }; + } + ); export type RawScheduleDefV9 = __Infer; -export const RawScopedTypeNameV10 = __t.object('RawScopedTypeNameV10', { - scope: __t.array(__t.string()), - sourceName: __t.string(), -}); +export const RawScopedTypeNameV10 = __t + .object('RawScopedTypeNameV10', { + scope: __t.array(__t.string()), + sourceName: __t.string(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.scope.length); + for (const __e0 of value.scope) { + writer.writeString(__e0); + } + writer.writeString(value.sourceName); + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readString(); + } + __f0 = __arr0; + } + let __f1: any; + __f1 = reader.readString(); + return { scope: __f0, sourceName: __f1 }; + } + ); export type RawScopedTypeNameV10 = __Infer; -export const RawScopedTypeNameV9 = __t.object('RawScopedTypeNameV9', { - scope: __t.array(__t.string()), - name: __t.string(), -}); +export const RawScopedTypeNameV9 = __t + .object('RawScopedTypeNameV9', { + scope: __t.array(__t.string()), + name: __t.string(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.scope.length); + for (const __e0 of value.scope) { + writer.writeString(__e0); + } + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readString(); + } + __f0 = __arr0; + } + let __f1: any; + __f1 = reader.readString(); + return { scope: __f0, name: __f1 }; + } + ); export type RawScopedTypeNameV9 = __Infer; -export const RawSequenceDefV10 = __t.object('RawSequenceDefV10', { - sourceName: __t.option(__t.string()), - column: __t.u16(), - start: __t.option(__t.i128()), - minValue: __t.option(__t.i128()), - maxValue: __t.option(__t.i128()), - increment: __t.i128(), -}); +export const RawSequenceDefV10 = __t + .object('RawSequenceDefV10', { + sourceName: __t.option(__t.string()), + column: __t.u16(), + start: __t.option(__t.i128()), + minValue: __t.option(__t.i128()), + maxValue: __t.option(__t.i128()), + increment: __t.i128(), + }) + .withSerde( + (writer, value: any) => { + if (value.sourceName === undefined || value.sourceName === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.sourceName); + } + writer.writeU16(value.column); + if (value.start === undefined || value.start === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.start); + } + if (value.minValue === undefined || value.minValue === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.minValue); + } + if (value.maxValue === undefined || value.maxValue === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.maxValue); + } + writer.writeI128(value.increment); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = reader.readU16(); + let __f2: any; + if (reader.readByte() === 0) { + __f2 = reader.readI128(); + } else { + __f2 = undefined; + } + let __f3: any; + if (reader.readByte() === 0) { + __f3 = reader.readI128(); + } else { + __f3 = undefined; + } + let __f4: any; + if (reader.readByte() === 0) { + __f4 = reader.readI128(); + } else { + __f4 = undefined; + } + let __f5: any; + __f5 = reader.readI128(); + return { + sourceName: __f0, + column: __f1, + start: __f2, + minValue: __f3, + maxValue: __f4, + increment: __f5, + }; + } + ); export type RawSequenceDefV10 = __Infer; -export const RawSequenceDefV8 = __t.object('RawSequenceDefV8', { - sequenceName: __t.string(), - colPos: __t.u16(), - increment: __t.i128(), - start: __t.option(__t.i128()), - minValue: __t.option(__t.i128()), - maxValue: __t.option(__t.i128()), - allocated: __t.i128(), -}); +export const RawSequenceDefV8 = __t + .object('RawSequenceDefV8', { + sequenceName: __t.string(), + colPos: __t.u16(), + increment: __t.i128(), + start: __t.option(__t.i128()), + minValue: __t.option(__t.i128()), + maxValue: __t.option(__t.i128()), + allocated: __t.i128(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sequenceName); + writer.writeU16(value.colPos); + writer.writeI128(value.increment); + if (value.start === undefined || value.start === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.start); + } + if (value.minValue === undefined || value.minValue === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.minValue); + } + if (value.maxValue === undefined || value.maxValue === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.maxValue); + } + writer.writeI128(value.allocated); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU16(); + let __f2: any; + __f2 = reader.readI128(); + let __f3: any; + if (reader.readByte() === 0) { + __f3 = reader.readI128(); + } else { + __f3 = undefined; + } + let __f4: any; + if (reader.readByte() === 0) { + __f4 = reader.readI128(); + } else { + __f4 = undefined; + } + let __f5: any; + if (reader.readByte() === 0) { + __f5 = reader.readI128(); + } else { + __f5 = undefined; + } + let __f6: any; + __f6 = reader.readI128(); + return { + sequenceName: __f0, + colPos: __f1, + increment: __f2, + start: __f3, + minValue: __f4, + maxValue: __f5, + allocated: __f6, + }; + } + ); export type RawSequenceDefV8 = __Infer; -export const RawSequenceDefV9 = __t.object('RawSequenceDefV9', { - name: __t.option(__t.string()), - column: __t.u16(), - start: __t.option(__t.i128()), - minValue: __t.option(__t.i128()), - maxValue: __t.option(__t.i128()), - increment: __t.i128(), -}); +export const RawSequenceDefV9 = __t + .object('RawSequenceDefV9', { + name: __t.option(__t.string()), + column: __t.u16(), + start: __t.option(__t.i128()), + minValue: __t.option(__t.i128()), + maxValue: __t.option(__t.i128()), + increment: __t.i128(), + }) + .withSerde( + (writer, value: any) => { + if (value.name === undefined || value.name === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.name); + } + writer.writeU16(value.column); + if (value.start === undefined || value.start === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.start); + } + if (value.minValue === undefined || value.minValue === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.minValue); + } + if (value.maxValue === undefined || value.maxValue === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeI128(value.maxValue); + } + writer.writeI128(value.increment); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = reader.readU16(); + let __f2: any; + if (reader.readByte() === 0) { + __f2 = reader.readI128(); + } else { + __f2 = undefined; + } + let __f3: any; + if (reader.readByte() === 0) { + __f3 = reader.readI128(); + } else { + __f3 = undefined; + } + let __f4: any; + if (reader.readByte() === 0) { + __f4 = reader.readI128(); + } else { + __f4 = undefined; + } + let __f5: any; + __f5 = reader.readI128(); + return { + name: __f0, + column: __f1, + start: __f2, + minValue: __f3, + maxValue: __f4, + increment: __f5, + }; + } + ); export type RawSequenceDefV9 = __Infer; -export const RawTableDefV10 = __t.object('RawTableDefV10', { - sourceName: __t.string(), - productTypeRef: __t.u32(), - primaryKey: __t.array(__t.u16()), - get indexes() { - return __t.array(RawIndexDefV10); - }, - get constraints() { - return __t.array(RawConstraintDefV10); - }, - get sequences() { - return __t.array(RawSequenceDefV10); - }, - get tableType() { - return TableType; - }, - get tableAccess() { - return TableAccess; - }, - get defaultValues() { - return __t.array(RawColumnDefaultValueV10); - }, - isEvent: __t.bool(), -}); +export const RawTableDefV10 = __t + .object('RawTableDefV10', { + sourceName: __t.string(), + productTypeRef: __t.u32(), + primaryKey: __t.array(__t.u16()), + get indexes() { + return __t.array(RawIndexDefV10); + }, + get constraints() { + return __t.array(RawConstraintDefV10); + }, + get sequences() { + return __t.array(RawSequenceDefV10); + }, + get tableType() { + return TableType; + }, + get tableAccess() { + return TableAccess; + }, + get defaultValues() { + return __t.array(RawColumnDefaultValueV10); + }, + isEvent: __t.bool(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sourceName); + writer.writeU32(value.productTypeRef); + writer.writeU32(value.primaryKey.length); + for (const __e0 of value.primaryKey) { + writer.writeU16(__e0); + } + writer.writeU32(value.indexes.length); + for (const __e1 of value.indexes) { + RawIndexDefV10.serialize(writer, __e1); + } + writer.writeU32(value.constraints.length); + for (const __e2 of value.constraints) { + RawConstraintDefV10.serialize(writer, __e2); + } + writer.writeU32(value.sequences.length); + for (const __e3 of value.sequences) { + RawSequenceDefV10.serialize(writer, __e3); + } + TableType.serialize(writer, value.tableType); + TableAccess.serialize(writer, value.tableAccess); + writer.writeU32(value.defaultValues.length); + for (const __e4 of value.defaultValues) { + RawColumnDefaultValueV10.serialize(writer, __e4); + } + writer.writeBool(value.isEvent); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU16(); + } + __f2 = __arr0; + } + let __f3: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = RawIndexDefV10.deserialize(reader); + } + __f3 = __arr1; + } + let __f4: any; + { + const __len2 = reader.readU32(); + const __arr2: any[] = new Array(__len2); + for (let __i2 = 0; __i2 < __len2; __i2++) { + __arr2[__i2] = RawConstraintDefV10.deserialize(reader); + } + __f4 = __arr2; + } + let __f5: any; + { + const __len3 = reader.readU32(); + const __arr3: any[] = new Array(__len3); + for (let __i3 = 0; __i3 < __len3; __i3++) { + __arr3[__i3] = RawSequenceDefV10.deserialize(reader); + } + __f5 = __arr3; + } + let __f6: any; + __f6 = TableType.deserialize(reader); + let __f7: any; + __f7 = TableAccess.deserialize(reader); + let __f8: any; + { + const __len4 = reader.readU32(); + const __arr4: any[] = new Array(__len4); + for (let __i4 = 0; __i4 < __len4; __i4++) { + __arr4[__i4] = RawColumnDefaultValueV10.deserialize(reader); + } + __f8 = __arr4; + } + let __f9: any; + __f9 = reader.readBool(); + return { + sourceName: __f0, + productTypeRef: __f1, + primaryKey: __f2, + indexes: __f3, + constraints: __f4, + sequences: __f5, + tableType: __f6, + tableAccess: __f7, + defaultValues: __f8, + isEvent: __f9, + }; + } + ); export type RawTableDefV10 = __Infer; -export const RawTableDefV8 = __t.object('RawTableDefV8', { - tableName: __t.string(), - get columns() { - return __t.array(RawColumnDefV8); - }, - get indexes() { - return __t.array(RawIndexDefV8); - }, - get constraints() { - return __t.array(RawConstraintDefV8); - }, - get sequences() { - return __t.array(RawSequenceDefV8); - }, - tableType: __t.string(), - tableAccess: __t.string(), - scheduled: __t.option(__t.string()), -}); +export const RawTableDefV8 = __t + .object('RawTableDefV8', { + tableName: __t.string(), + get columns() { + return __t.array(RawColumnDefV8); + }, + get indexes() { + return __t.array(RawIndexDefV8); + }, + get constraints() { + return __t.array(RawConstraintDefV8); + }, + get sequences() { + return __t.array(RawSequenceDefV8); + }, + tableType: __t.string(), + tableAccess: __t.string(), + scheduled: __t.option(__t.string()), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.tableName); + writer.writeU32(value.columns.length); + for (const __e0 of value.columns) { + RawColumnDefV8.serialize(writer, __e0); + } + writer.writeU32(value.indexes.length); + for (const __e1 of value.indexes) { + RawIndexDefV8.serialize(writer, __e1); + } + writer.writeU32(value.constraints.length); + for (const __e2 of value.constraints) { + RawConstraintDefV8.serialize(writer, __e2); + } + writer.writeU32(value.sequences.length); + for (const __e3 of value.sequences) { + RawSequenceDefV8.serialize(writer, __e3); + } + writer.writeString(value.tableType); + writer.writeString(value.tableAccess); + if (value.scheduled === undefined || value.scheduled === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.scheduled); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = RawColumnDefV8.deserialize(reader); + } + __f1 = __arr0; + } + let __f2: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = RawIndexDefV8.deserialize(reader); + } + __f2 = __arr1; + } + let __f3: any; + { + const __len2 = reader.readU32(); + const __arr2: any[] = new Array(__len2); + for (let __i2 = 0; __i2 < __len2; __i2++) { + __arr2[__i2] = RawConstraintDefV8.deserialize(reader); + } + __f3 = __arr2; + } + let __f4: any; + { + const __len3 = reader.readU32(); + const __arr3: any[] = new Array(__len3); + for (let __i3 = 0; __i3 < __len3; __i3++) { + __arr3[__i3] = RawSequenceDefV8.deserialize(reader); + } + __f4 = __arr3; + } + let __f5: any; + __f5 = reader.readString(); + let __f6: any; + __f6 = reader.readString(); + let __f7: any; + if (reader.readByte() === 0) { + __f7 = reader.readString(); + } else { + __f7 = undefined; + } + return { + tableName: __f0, + columns: __f1, + indexes: __f2, + constraints: __f3, + sequences: __f4, + tableType: __f5, + tableAccess: __f6, + scheduled: __f7, + }; + } + ); export type RawTableDefV8 = __Infer; -export const RawTableDefV9 = __t.object('RawTableDefV9', { - name: __t.string(), - productTypeRef: __t.u32(), - primaryKey: __t.array(__t.u16()), - get indexes() { - return __t.array(RawIndexDefV9); - }, - get constraints() { - return __t.array(RawConstraintDefV9); - }, - get sequences() { - return __t.array(RawSequenceDefV9); - }, - get schedule() { - return __t.option(RawScheduleDefV9); - }, - get tableType() { - return TableType; - }, - get tableAccess() { - return TableAccess; - }, -}); +export const RawTableDefV9 = __t + .object('RawTableDefV9', { + name: __t.string(), + productTypeRef: __t.u32(), + primaryKey: __t.array(__t.u16()), + get indexes() { + return __t.array(RawIndexDefV9); + }, + get constraints() { + return __t.array(RawConstraintDefV9); + }, + get sequences() { + return __t.array(RawSequenceDefV9); + }, + get schedule() { + return __t.option(RawScheduleDefV9); + }, + get tableType() { + return TableType; + }, + get tableAccess() { + return TableAccess; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + writer.writeU32(value.productTypeRef); + writer.writeU32(value.primaryKey.length); + for (const __e0 of value.primaryKey) { + writer.writeU16(__e0); + } + writer.writeU32(value.indexes.length); + for (const __e1 of value.indexes) { + RawIndexDefV9.serialize(writer, __e1); + } + writer.writeU32(value.constraints.length); + for (const __e2 of value.constraints) { + RawConstraintDefV9.serialize(writer, __e2); + } + writer.writeU32(value.sequences.length); + for (const __e3 of value.sequences) { + RawSequenceDefV9.serialize(writer, __e3); + } + if (value.schedule === undefined || value.schedule === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + RawScheduleDefV9.serialize(writer, value.schedule); + } + TableType.serialize(writer, value.tableType); + TableAccess.serialize(writer, value.tableAccess); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU16(); + } + __f2 = __arr0; + } + let __f3: any; + { + const __len1 = reader.readU32(); + const __arr1: any[] = new Array(__len1); + for (let __i1 = 0; __i1 < __len1; __i1++) { + __arr1[__i1] = RawIndexDefV9.deserialize(reader); + } + __f3 = __arr1; + } + let __f4: any; + { + const __len2 = reader.readU32(); + const __arr2: any[] = new Array(__len2); + for (let __i2 = 0; __i2 < __len2; __i2++) { + __arr2[__i2] = RawConstraintDefV9.deserialize(reader); + } + __f4 = __arr2; + } + let __f5: any; + { + const __len3 = reader.readU32(); + const __arr3: any[] = new Array(__len3); + for (let __i3 = 0; __i3 < __len3; __i3++) { + __arr3[__i3] = RawSequenceDefV9.deserialize(reader); + } + __f5 = __arr3; + } + let __f6: any; + if (reader.readByte() === 0) { + __f6 = RawScheduleDefV9.deserialize(reader); + } else { + __f6 = undefined; + } + let __f7: any; + __f7 = TableType.deserialize(reader); + let __f8: any; + __f8 = TableAccess.deserialize(reader); + return { + name: __f0, + productTypeRef: __f1, + primaryKey: __f2, + indexes: __f3, + constraints: __f4, + sequences: __f5, + schedule: __f6, + tableType: __f7, + tableAccess: __f8, + }; + } + ); export type RawTableDefV9 = __Infer; -export const RawTypeDefV10 = __t.object('RawTypeDefV10', { - get sourceName() { - return RawScopedTypeNameV10; - }, - ty: __t.u32(), - customOrdering: __t.bool(), -}); +export const RawTypeDefV10 = __t + .object('RawTypeDefV10', { + get sourceName() { + return RawScopedTypeNameV10; + }, + ty: __t.u32(), + customOrdering: __t.bool(), + }) + .withSerde( + (writer, value: any) => { + RawScopedTypeNameV10.serialize(writer, value.sourceName); + writer.writeU32(value.ty); + writer.writeBool(value.customOrdering); + }, + (reader): any => { + let __f0: any; + __f0 = RawScopedTypeNameV10.deserialize(reader); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + __f2 = reader.readBool(); + return { sourceName: __f0, ty: __f1, customOrdering: __f2 }; + } + ); export type RawTypeDefV10 = __Infer; -export const RawTypeDefV9 = __t.object('RawTypeDefV9', { - get name() { - return RawScopedTypeNameV9; - }, - ty: __t.u32(), - customOrdering: __t.bool(), -}); +export const RawTypeDefV9 = __t + .object('RawTypeDefV9', { + get name() { + return RawScopedTypeNameV9; + }, + ty: __t.u32(), + customOrdering: __t.bool(), + }) + .withSerde( + (writer, value: any) => { + RawScopedTypeNameV9.serialize(writer, value.name); + writer.writeU32(value.ty); + writer.writeBool(value.customOrdering); + }, + (reader): any => { + let __f0: any; + __f0 = RawScopedTypeNameV9.deserialize(reader); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + __f2 = reader.readBool(); + return { name: __f0, ty: __f1, customOrdering: __f2 }; + } + ); export type RawTypeDefV9 = __Infer; -export const RawUniqueConstraintDataV9 = __t.object( - 'RawUniqueConstraintDataV9', - { +export const RawUniqueConstraintDataV9 = __t + .object('RawUniqueConstraintDataV9', { columns: __t.array(__t.u16()), - } -); + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.columns.length); + for (const __e0 of value.columns) { + writer.writeU16(__e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU16(); + } + __f0 = __arr0; + } + return { columns: __f0 }; + } + ); export type RawUniqueConstraintDataV9 = __Infer< typeof RawUniqueConstraintDataV9 >; -export const RawViewDefV10 = __t.object('RawViewDefV10', { - sourceName: __t.string(), - index: __t.u32(), - isPublic: __t.bool(), - isAnonymous: __t.bool(), - get params() { - return ProductType; - }, - get returnType() { - return AlgebraicType; - }, -}); +export const RawViewDefV10 = __t + .object('RawViewDefV10', { + sourceName: __t.string(), + index: __t.u32(), + isPublic: __t.bool(), + isAnonymous: __t.bool(), + get params() { + return ProductType; + }, + get returnType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.sourceName); + writer.writeU32(value.index); + writer.writeBool(value.isPublic); + writer.writeBool(value.isAnonymous); + ProductType.serialize(writer, value.params); + AlgebraicType.serialize(writer, value.returnType); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + __f2 = reader.readBool(); + let __f3: any; + __f3 = reader.readBool(); + let __f4: any; + __f4 = ProductType.deserialize(reader); + let __f5: any; + __f5 = AlgebraicType.deserialize(reader); + return { + sourceName: __f0, + index: __f1, + isPublic: __f2, + isAnonymous: __f3, + params: __f4, + returnType: __f5, + }; + } + ); export type RawViewDefV10 = __Infer; -export const RawViewDefV9 = __t.object('RawViewDefV9', { - name: __t.string(), - index: __t.u32(), - isPublic: __t.bool(), - isAnonymous: __t.bool(), - get params() { - return ProductType; - }, - get returnType() { - return AlgebraicType; - }, -}); +export const RawViewDefV9 = __t + .object('RawViewDefV9', { + name: __t.string(), + index: __t.u32(), + isPublic: __t.bool(), + isAnonymous: __t.bool(), + get params() { + return ProductType; + }, + get returnType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + writer.writeU32(value.index); + writer.writeBool(value.isPublic); + writer.writeBool(value.isAnonymous); + ProductType.serialize(writer, value.params); + AlgebraicType.serialize(writer, value.returnType); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + __f2 = reader.readBool(); + let __f3: any; + __f3 = reader.readBool(); + let __f4: any; + __f4 = ProductType.deserialize(reader); + let __f5: any; + __f5 = AlgebraicType.deserialize(reader); + return { + name: __f0, + index: __f1, + isPublic: __f2, + isAnonymous: __f3, + params: __f4, + returnType: __f5, + }; + } + ); export type RawViewDefV9 = __Infer; -export const ReducerDef = __t.object('ReducerDef', { - name: __t.string(), - get args() { - return __t.array(ProductTypeElement); - }, -}); +export const ReducerDef = __t + .object('ReducerDef', { + name: __t.string(), + get args() { + return __t.array(ProductTypeElement); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + writer.writeU32(value.args.length); + for (const __e0 of value.args) { + ProductTypeElement.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = ProductTypeElement.deserialize(reader); + } + __f1 = __arr0; + } + return { name: __f0, args: __f1 }; + } + ); export type ReducerDef = __Infer; -export const SumType = __t.object('SumType', { - get variants() { - return __t.array(SumTypeVariant); - }, -}); +export const SumType = __t + .object('SumType', { + get variants() { + return __t.array(SumTypeVariant); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.variants.length); + for (const __e0 of value.variants) { + SumTypeVariant.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = SumTypeVariant.deserialize(reader); + } + __f0 = __arr0; + } + return { variants: __f0 }; + } + ); export type SumType = __Infer; -export const SumTypeVariant = __t.object('SumTypeVariant', { - name: __t.option(__t.string()), - get algebraicType() { - return AlgebraicType; - }, -}); +export const SumTypeVariant = __t + .object('SumTypeVariant', { + name: __t.option(__t.string()), + get algebraicType() { + return AlgebraicType; + }, + }) + .withSerde( + (writer, value: any) => { + if (value.name === undefined || value.name === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeString(value.name); + } + AlgebraicType.serialize(writer, value.algebraicType); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readString(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = AlgebraicType.deserialize(reader); + return { name: __f0, algebraicType: __f1 }; + } + ); export type SumTypeVariant = __Infer; // The tagged union or sum type for the algebraic type `TableAccess`. -export const TableAccess = __t.enum('TableAccess', { - Public: __t.unit(), - Private: __t.unit(), -}); +export const TableAccess = __t + .enum('TableAccess', { + Public: __t.unit(), + Private: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Public': { + writer.writeByte(0); + break; + } + case 'Private': { + writer.writeByte(1); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'Public', value: {} }; + } + case 1: { + return { tag: 'Private', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type TableAccess = __Infer; -export const TableDesc = __t.object('TableDesc', { - get schema() { - return RawTableDefV8; - }, - data: __t.u32(), -}); +export const TableDesc = __t + .object('TableDesc', { + get schema() { + return RawTableDefV8; + }, + data: __t.u32(), + }) + .withSerde( + (writer, value: any) => { + RawTableDefV8.serialize(writer, value.schema); + writer.writeU32(value.data); + }, + (reader): any => { + let __f0: any; + __f0 = RawTableDefV8.deserialize(reader); + let __f1: any; + __f1 = reader.readU32(); + return { schema: __f0, data: __f1 }; + } + ); export type TableDesc = __Infer; // The tagged union or sum type for the algebraic type `TableType`. -export const TableType = __t.enum('TableType', { - System: __t.unit(), - User: __t.unit(), -}); +export const TableType = __t + .enum('TableType', { + System: __t.unit(), + User: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'System': { + writer.writeByte(0); + break; + } + case 'User': { + writer.writeByte(1); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'System', value: {} }; + } + case 1: { + return { tag: 'User', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type TableType = __Infer; -export const TypeAlias = __t.object('TypeAlias', { - name: __t.string(), - ty: __t.u32(), -}); +export const TypeAlias = __t + .object('TypeAlias', { + name: __t.string(), + ty: __t.u32(), + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.name); + writer.writeU32(value.ty); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = reader.readU32(); + return { name: __f0, ty: __f1 }; + } + ); export type TypeAlias = __Infer; -export const Typespace = __t.object('Typespace', { - get types() { - return __t.array(AlgebraicType); - }, -}); +export const Typespace = __t + .object('Typespace', { + get types() { + return __t.array(AlgebraicType); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.types.length); + for (const __e0 of value.types) { + AlgebraicType.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = AlgebraicType.deserialize(reader); + } + __f0 = __arr0; + } + return { types: __f0 }; + } + ); export type Typespace = __Infer; // The tagged union or sum type for the algebraic type `ViewResultHeader`. -export const ViewResultHeader = __t.enum('ViewResultHeader', { - RowData: __t.unit(), - RawSql: __t.string(), -}); +export const ViewResultHeader = __t + .enum('ViewResultHeader', { + RowData: __t.unit(), + RawSql: __t.string(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'RowData': { + writer.writeByte(0); + break; + } + case 'RawSql': { + writer.writeByte(1); + writer.writeString(value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'RowData', value: {} }; + } + case 1: { + let __v: any; + __v = reader.readString(); + return { tag: 'RawSql', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type ViewResultHeader = __Infer; diff --git a/crates/bindings-typescript/src/lib/type_builders.ts b/crates/bindings-typescript/src/lib/type_builders.ts index 6bf8ae1ec99..4c8953ac8cd 100644 --- a/crates/bindings-typescript/src/lib/type_builders.ts +++ b/crates/bindings-typescript/src/lib/type_builders.ts @@ -1,4 +1,10 @@ -import { AlgebraicType, type AlgebraicTypeVariants } from './algebraic_type'; +import { + AlgebraicType, + registerSerde, + type AlgebraicTypeVariants, + type Deserializer, + type Serializer, +} from './algebraic_type'; import type BinaryReader from './binary_reader'; import type BinaryWriter from './binary_writer'; import { ConnectionId, type ConnectionIdAlgebraicType } from './connection_id'; @@ -12,6 +18,10 @@ import { Timestamp, type TimestampAlgebraicType } from './timestamp'; import { set, type Prettify, type SetField } from './type_util'; import { Uuid, type UuidAlgebraicType } from './uuid'; +// Re-export the wrapper classes used by codegen-emitted static +// serializers/deserializers (e.g. `new __Identity(reader.readU256())`). +export { ConnectionId, Identity, TimeDuration, Timestamp, Uuid }; + // Used in codegen files export { type AlgebraicTypeType } from './algebraic_type'; @@ -190,6 +200,30 @@ export class TypeBuilder )); return deserialize(reader); } + + /** + * Install a precomputed serializer/deserializer for this type builder. + * + * Code generation calls this for named compound types (`Product` and `Sum`) + * so that the runtime never has to build serializers via a tree walker. The + * provided functions are both attached to this builder *and* registered in + * the shared {@link registerSerde} cache keyed by `this.algebraicType.value`, + * so direct callers of `AlgebraicType.makeSerializer` / `makeDeserializer` + * (e.g. the client SDK looking up a table row deserializer) pick them up + * automatically. + */ + withSerde( + serialize: Serializer, + deserialize: Deserializer + ): this { + this.serialize = serialize as (writer: BinaryWriter, value: Type) => void; + this.deserialize = deserialize as (reader: BinaryReader) => Type; + const at: AlgebraicType = this.algebraicType; + if (at.tag === 'Product' || at.tag === 'Sum') { + registerSerde(at.value, serialize, deserialize); + } + return this; + } } /** diff --git a/crates/bindings-typescript/src/sdk/client_api/index.ts b/crates/bindings-typescript/src/sdk/client_api/index.ts index 85be7b0c365..bf71b6a8189 100644 --- a/crates/bindings-typescript/src/sdk/client_api/index.ts +++ b/crates/bindings-typescript/src/sdk/client_api/index.ts @@ -1,14 +1,18 @@ // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD. -// This was generated using spacetimedb cli version 2.0.0 (commit 098afaf1a5ed935bce5a32c88620e829506effe7). +// This was generated using spacetimedb cli version 2.2.0 (commit be86a512f2bcd610674202317255e82def655499). /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, DbConnectionBuilder as __DbConnectionBuilder, DbConnectionImpl as __DbConnectionImpl, + Identity as __Identity, SubscriptionBuilderImpl as __SubscriptionBuilderImpl, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, Uuid as __Uuid, convertToAccessorMap as __convertToAccessorMap, @@ -53,7 +57,7 @@ const proceduresSchema = __procedures(); /** The remote SpacetimeDB module schema, both runtime and type information. */ const REMOTE_MODULE = { versionInfo: { - cliVersion: '2.0.0' as const, + cliVersion: '2.2.0' as const, }, tables: tablesSchema.schemaType.tables, reducers: reducersSchema.reducersType.reducers, @@ -73,6 +77,9 @@ export const reducers = __convertToAccessorMap( reducersSchema.reducersType.reducers ); +/** The procedures available in this remote SpacetimeDB module. */ +export const procedures = __convertToAccessorMap(proceduresSchema.procedures); + /** The context type returned in callbacks for all possible events. */ export type EventContext = __EventContextInterface; /** The context type returned in callbacks for reducer events. */ diff --git a/crates/bindings-typescript/src/sdk/client_api/types.ts b/crates/bindings-typescript/src/sdk/client_api/types.ts index 709a114da28..14bc4643c10 100644 --- a/crates/bindings-typescript/src/sdk/client_api/types.ts +++ b/crates/bindings-typescript/src/sdk/client_api/types.ts @@ -4,285 +4,1101 @@ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, } from '../../lib/type_builders'; -export const BsatnRowList = __t.object('BsatnRowList', { - get sizeHint() { - return RowSizeHint; - }, - rowsData: __t.byteArray(), -}); +export const BsatnRowList = __t + .object('BsatnRowList', { + get sizeHint() { + return RowSizeHint; + }, + rowsData: __t.byteArray(), + }) + .withSerde( + (writer, value: any) => { + RowSizeHint.serialize(writer, value.sizeHint); + writer.writeUInt8Array(value.rowsData); + }, + (reader): any => { + let __f0: any; + __f0 = RowSizeHint.deserialize(reader); + let __f1: any; + __f1 = reader.readUInt8Array(); + return { sizeHint: __f0, rowsData: __f1 }; + } + ); export type BsatnRowList = __Infer; -export const CallProcedure = __t.object('CallProcedure', { - requestId: __t.u32(), - flags: __t.u8(), - procedure: __t.string(), - args: __t.byteArray(), -}); +export const CallProcedure = __t + .object('CallProcedure', { + requestId: __t.u32(), + flags: __t.u8(), + procedure: __t.string(), + args: __t.byteArray(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + writer.writeU8(value.flags); + writer.writeString(value.procedure); + writer.writeUInt8Array(value.args); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readU8(); + let __f2: any; + __f2 = reader.readString(); + let __f3: any; + __f3 = reader.readUInt8Array(); + return { requestId: __f0, flags: __f1, procedure: __f2, args: __f3 }; + } + ); export type CallProcedure = __Infer; -export const CallReducer = __t.object('CallReducer', { - requestId: __t.u32(), - flags: __t.u8(), - reducer: __t.string(), - args: __t.byteArray(), -}); +export const CallReducer = __t + .object('CallReducer', { + requestId: __t.u32(), + flags: __t.u8(), + reducer: __t.string(), + args: __t.byteArray(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + writer.writeU8(value.flags); + writer.writeString(value.reducer); + writer.writeUInt8Array(value.args); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readU8(); + let __f2: any; + __f2 = reader.readString(); + let __f3: any; + __f3 = reader.readUInt8Array(); + return { requestId: __f0, flags: __f1, reducer: __f2, args: __f3 }; + } + ); export type CallReducer = __Infer; // The tagged union or sum type for the algebraic type `ClientMessage`. -export const ClientMessage = __t.enum('ClientMessage', { - get Subscribe() { - return Subscribe; - }, - get Unsubscribe() { - return Unsubscribe; - }, - get OneOffQuery() { - return OneOffQuery; - }, - get CallReducer() { - return CallReducer; - }, - get CallProcedure() { - return CallProcedure; - }, -}); +export const ClientMessage = __t + .enum('ClientMessage', { + get Subscribe() { + return Subscribe; + }, + get Unsubscribe() { + return Unsubscribe; + }, + get OneOffQuery() { + return OneOffQuery; + }, + get CallReducer() { + return CallReducer; + }, + get CallProcedure() { + return CallProcedure; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Subscribe': { + writer.writeByte(0); + Subscribe.serialize(writer, value.value); + break; + } + case 'Unsubscribe': { + writer.writeByte(1); + Unsubscribe.serialize(writer, value.value); + break; + } + case 'OneOffQuery': { + writer.writeByte(2); + OneOffQuery.serialize(writer, value.value); + break; + } + case 'CallReducer': { + writer.writeByte(3); + CallReducer.serialize(writer, value.value); + break; + } + case 'CallProcedure': { + writer.writeByte(4); + CallProcedure.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = Subscribe.deserialize(reader); + return { tag: 'Subscribe', value: __v }; + } + case 1: { + let __v: any; + __v = Unsubscribe.deserialize(reader); + return { tag: 'Unsubscribe', value: __v }; + } + case 2: { + let __v: any; + __v = OneOffQuery.deserialize(reader); + return { tag: 'OneOffQuery', value: __v }; + } + case 3: { + let __v: any; + __v = CallReducer.deserialize(reader); + return { tag: 'CallReducer', value: __v }; + } + case 4: { + let __v: any; + __v = CallProcedure.deserialize(reader); + return { tag: 'CallProcedure', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type ClientMessage = __Infer; -export const EventTableRows = __t.object('EventTableRows', { - get events() { - return BsatnRowList; - }, -}); +export const EventTableRows = __t + .object('EventTableRows', { + get events() { + return BsatnRowList; + }, + }) + .withSerde( + (writer, value: any) => { + BsatnRowList.serialize(writer, value.events); + }, + (reader): any => { + let __f0: any; + __f0 = BsatnRowList.deserialize(reader); + return { events: __f0 }; + } + ); export type EventTableRows = __Infer; -export const InitialConnection = __t.object('InitialConnection', { - identity: __t.identity(), - connectionId: __t.connectionId(), - token: __t.string(), -}); +export const InitialConnection = __t + .object('InitialConnection', { + identity: __t.identity(), + connectionId: __t.connectionId(), + token: __t.string(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU256(value.identity.__identity__); + writer.writeU128(value.connectionId.__connection_id__); + writer.writeString(value.token); + }, + (reader): any => { + let __f0: any; + __f0 = new __Identity(reader.readU256()); + let __f1: any; + __f1 = new __ConnectionId(reader.readU128()); + let __f2: any; + __f2 = reader.readString(); + return { identity: __f0, connectionId: __f1, token: __f2 }; + } + ); export type InitialConnection = __Infer; -export const OneOffQuery = __t.object('OneOffQuery', { - requestId: __t.u32(), - queryString: __t.string(), -}); +export const OneOffQuery = __t + .object('OneOffQuery', { + requestId: __t.u32(), + queryString: __t.string(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + writer.writeString(value.queryString); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readString(); + return { requestId: __f0, queryString: __f1 }; + } + ); export type OneOffQuery = __Infer; -export const OneOffQueryResult = __t.object('OneOffQueryResult', { - requestId: __t.u32(), - get result() { - return __t.result(QueryRows, __t.string()); - }, -}); +export const OneOffQueryResult = __t + .object('OneOffQueryResult', { + requestId: __t.u32(), + get result() { + return __t.result(QueryRows, __t.string()); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + if ('ok' in value.result) { + writer.writeByte(0); + QueryRows.serialize(writer, value.result.ok); + } else { + writer.writeByte(1); + writer.writeString(value.result.err); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + { + const __tag0 = reader.readByte(); + if (__tag0 === 0) { + let __r0: any; + __r0 = QueryRows.deserialize(reader); + __f1 = { ok: __r0 }; + } else { + let __r0: any; + __r0 = reader.readString(); + __f1 = { err: __r0 }; + } + } + return { requestId: __f0, result: __f1 }; + } + ); export type OneOffQueryResult = __Infer; -export const PersistentTableRows = __t.object('PersistentTableRows', { - get inserts() { - return BsatnRowList; - }, - get deletes() { - return BsatnRowList; - }, -}); +export const PersistentTableRows = __t + .object('PersistentTableRows', { + get inserts() { + return BsatnRowList; + }, + get deletes() { + return BsatnRowList; + }, + }) + .withSerde( + (writer, value: any) => { + BsatnRowList.serialize(writer, value.inserts); + BsatnRowList.serialize(writer, value.deletes); + }, + (reader): any => { + let __f0: any; + __f0 = BsatnRowList.deserialize(reader); + let __f1: any; + __f1 = BsatnRowList.deserialize(reader); + return { inserts: __f0, deletes: __f1 }; + } + ); export type PersistentTableRows = __Infer; -export const ProcedureResult = __t.object('ProcedureResult', { - get status() { - return ProcedureStatus; - }, - timestamp: __t.timestamp(), - totalHostExecutionDuration: __t.timeDuration(), - requestId: __t.u32(), -}); +export const ProcedureResult = __t + .object('ProcedureResult', { + get status() { + return ProcedureStatus; + }, + timestamp: __t.timestamp(), + totalHostExecutionDuration: __t.timeDuration(), + requestId: __t.u32(), + }) + .withSerde( + (writer, value: any) => { + ProcedureStatus.serialize(writer, value.status); + writer.writeI64(value.timestamp.__timestamp_micros_since_unix_epoch__); + writer.writeI64( + value.totalHostExecutionDuration.__time_duration_micros__ + ); + writer.writeU32(value.requestId); + }, + (reader): any => { + let __f0: any; + __f0 = ProcedureStatus.deserialize(reader); + let __f1: any; + __f1 = new __Timestamp(reader.readI64()); + let __f2: any; + __f2 = new __TimeDuration(reader.readI64()); + let __f3: any; + __f3 = reader.readU32(); + return { + status: __f0, + timestamp: __f1, + totalHostExecutionDuration: __f2, + requestId: __f3, + }; + } + ); export type ProcedureResult = __Infer; // The tagged union or sum type for the algebraic type `ProcedureStatus`. -export const ProcedureStatus = __t.enum('ProcedureStatus', { - Returned: __t.byteArray(), - InternalError: __t.string(), -}); +export const ProcedureStatus = __t + .enum('ProcedureStatus', { + Returned: __t.byteArray(), + InternalError: __t.string(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Returned': { + writer.writeByte(0); + writer.writeUInt8Array(value.value); + break; + } + case 'InternalError': { + writer.writeByte(1); + writer.writeString(value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = reader.readUInt8Array(); + return { tag: 'Returned', value: __v }; + } + case 1: { + let __v: any; + __v = reader.readString(); + return { tag: 'InternalError', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type ProcedureStatus = __Infer; -export const QueryRows = __t.object('QueryRows', { - get tables() { - return __t.array(SingleTableRows); - }, -}); +export const QueryRows = __t + .object('QueryRows', { + get tables() { + return __t.array(SingleTableRows); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.tables.length); + for (const __e0 of value.tables) { + SingleTableRows.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = SingleTableRows.deserialize(reader); + } + __f0 = __arr0; + } + return { tables: __f0 }; + } + ); export type QueryRows = __Infer; -export const QuerySetId = __t.object('QuerySetId', { - id: __t.u32(), -}); +export const QuerySetId = __t + .object('QuerySetId', { + id: __t.u32(), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.id); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + return { id: __f0 }; + } + ); export type QuerySetId = __Infer; -export const QuerySetUpdate = __t.object('QuerySetUpdate', { - get querySetId() { - return QuerySetId; - }, - get tables() { - return __t.array(TableUpdate); - }, -}); +export const QuerySetUpdate = __t + .object('QuerySetUpdate', { + get querySetId() { + return QuerySetId; + }, + get tables() { + return __t.array(TableUpdate); + }, + }) + .withSerde( + (writer, value: any) => { + QuerySetId.serialize(writer, value.querySetId); + writer.writeU32(value.tables.length); + for (const __e0 of value.tables) { + TableUpdate.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + __f0 = QuerySetId.deserialize(reader); + let __f1: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = TableUpdate.deserialize(reader); + } + __f1 = __arr0; + } + return { querySetId: __f0, tables: __f1 }; + } + ); export type QuerySetUpdate = __Infer; -export const ReducerOk = __t.object('ReducerOk', { - retValue: __t.byteArray(), - get transactionUpdate() { - return TransactionUpdate; - }, -}); +export const ReducerOk = __t + .object('ReducerOk', { + retValue: __t.byteArray(), + get transactionUpdate() { + return TransactionUpdate; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeUInt8Array(value.retValue); + TransactionUpdate.serialize(writer, value.transactionUpdate); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readUInt8Array(); + let __f1: any; + __f1 = TransactionUpdate.deserialize(reader); + return { retValue: __f0, transactionUpdate: __f1 }; + } + ); export type ReducerOk = __Infer; // The tagged union or sum type for the algebraic type `ReducerOutcome`. -export const ReducerOutcome = __t.enum('ReducerOutcome', { - get Ok() { - return ReducerOk; - }, - OkEmpty: __t.unit(), - Err: __t.byteArray(), - InternalError: __t.string(), -}); +export const ReducerOutcome = __t + .enum('ReducerOutcome', { + get Ok() { + return ReducerOk; + }, + OkEmpty: __t.unit(), + Err: __t.byteArray(), + InternalError: __t.string(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Ok': { + writer.writeByte(0); + ReducerOk.serialize(writer, value.value); + break; + } + case 'OkEmpty': { + writer.writeByte(1); + break; + } + case 'Err': { + writer.writeByte(2); + writer.writeUInt8Array(value.value); + break; + } + case 'InternalError': { + writer.writeByte(3); + writer.writeString(value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = ReducerOk.deserialize(reader); + return { tag: 'Ok', value: __v }; + } + case 1: { + return { tag: 'OkEmpty', value: {} }; + } + case 2: { + let __v: any; + __v = reader.readUInt8Array(); + return { tag: 'Err', value: __v }; + } + case 3: { + let __v: any; + __v = reader.readString(); + return { tag: 'InternalError', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type ReducerOutcome = __Infer; -export const ReducerResult = __t.object('ReducerResult', { - requestId: __t.u32(), - timestamp: __t.timestamp(), - get result() { - return ReducerOutcome; - }, -}); +export const ReducerResult = __t + .object('ReducerResult', { + requestId: __t.u32(), + timestamp: __t.timestamp(), + get result() { + return ReducerOutcome; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + writer.writeI64(value.timestamp.__timestamp_micros_since_unix_epoch__); + ReducerOutcome.serialize(writer, value.result); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = new __Timestamp(reader.readI64()); + let __f2: any; + __f2 = ReducerOutcome.deserialize(reader); + return { requestId: __f0, timestamp: __f1, result: __f2 }; + } + ); export type ReducerResult = __Infer; // The tagged union or sum type for the algebraic type `RowSizeHint`. -export const RowSizeHint = __t.enum('RowSizeHint', { - FixedSize: __t.u16(), - RowOffsets: __t.array(__t.u64()), -}); +export const RowSizeHint = __t + .enum('RowSizeHint', { + FixedSize: __t.u16(), + RowOffsets: __t.array(__t.u64()), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'FixedSize': { + writer.writeByte(0); + writer.writeU16(value.value); + break; + } + case 'RowOffsets': { + writer.writeByte(1); + writer.writeU32(value.value.length); + for (const __e0 of value.value) { + writer.writeU64(__e0); + } + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = reader.readU16(); + return { tag: 'FixedSize', value: __v }; + } + case 1: { + let __v: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readU64(); + } + __v = __arr0; + } + return { tag: 'RowOffsets', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type RowSizeHint = __Infer; // The tagged union or sum type for the algebraic type `ServerMessage`. -export const ServerMessage = __t.enum('ServerMessage', { - get InitialConnection() { - return InitialConnection; - }, - get SubscribeApplied() { - return SubscribeApplied; - }, - get UnsubscribeApplied() { - return UnsubscribeApplied; - }, - get SubscriptionError() { - return SubscriptionError; - }, - get TransactionUpdate() { - return TransactionUpdate; - }, - get OneOffQueryResult() { - return OneOffQueryResult; - }, - get ReducerResult() { - return ReducerResult; - }, - get ProcedureResult() { - return ProcedureResult; - }, -}); +export const ServerMessage = __t + .enum('ServerMessage', { + get InitialConnection() { + return InitialConnection; + }, + get SubscribeApplied() { + return SubscribeApplied; + }, + get UnsubscribeApplied() { + return UnsubscribeApplied; + }, + get SubscriptionError() { + return SubscriptionError; + }, + get TransactionUpdate() { + return TransactionUpdate; + }, + get OneOffQueryResult() { + return OneOffQueryResult; + }, + get ReducerResult() { + return ReducerResult; + }, + get ProcedureResult() { + return ProcedureResult; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'InitialConnection': { + writer.writeByte(0); + InitialConnection.serialize(writer, value.value); + break; + } + case 'SubscribeApplied': { + writer.writeByte(1); + SubscribeApplied.serialize(writer, value.value); + break; + } + case 'UnsubscribeApplied': { + writer.writeByte(2); + UnsubscribeApplied.serialize(writer, value.value); + break; + } + case 'SubscriptionError': { + writer.writeByte(3); + SubscriptionError.serialize(writer, value.value); + break; + } + case 'TransactionUpdate': { + writer.writeByte(4); + TransactionUpdate.serialize(writer, value.value); + break; + } + case 'OneOffQueryResult': { + writer.writeByte(5); + OneOffQueryResult.serialize(writer, value.value); + break; + } + case 'ReducerResult': { + writer.writeByte(6); + ReducerResult.serialize(writer, value.value); + break; + } + case 'ProcedureResult': { + writer.writeByte(7); + ProcedureResult.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = InitialConnection.deserialize(reader); + return { tag: 'InitialConnection', value: __v }; + } + case 1: { + let __v: any; + __v = SubscribeApplied.deserialize(reader); + return { tag: 'SubscribeApplied', value: __v }; + } + case 2: { + let __v: any; + __v = UnsubscribeApplied.deserialize(reader); + return { tag: 'UnsubscribeApplied', value: __v }; + } + case 3: { + let __v: any; + __v = SubscriptionError.deserialize(reader); + return { tag: 'SubscriptionError', value: __v }; + } + case 4: { + let __v: any; + __v = TransactionUpdate.deserialize(reader); + return { tag: 'TransactionUpdate', value: __v }; + } + case 5: { + let __v: any; + __v = OneOffQueryResult.deserialize(reader); + return { tag: 'OneOffQueryResult', value: __v }; + } + case 6: { + let __v: any; + __v = ReducerResult.deserialize(reader); + return { tag: 'ReducerResult', value: __v }; + } + case 7: { + let __v: any; + __v = ProcedureResult.deserialize(reader); + return { tag: 'ProcedureResult', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type ServerMessage = __Infer; -export const SingleTableRows = __t.object('SingleTableRows', { - table: __t.string(), - get rows() { - return BsatnRowList; - }, -}); +export const SingleTableRows = __t + .object('SingleTableRows', { + table: __t.string(), + get rows() { + return BsatnRowList; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.table); + BsatnRowList.serialize(writer, value.rows); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + __f1 = BsatnRowList.deserialize(reader); + return { table: __f0, rows: __f1 }; + } + ); export type SingleTableRows = __Infer; -export const Subscribe = __t.object('Subscribe', { - requestId: __t.u32(), - get querySetId() { - return QuerySetId; - }, - queryStrings: __t.array(__t.string()), -}); +export const Subscribe = __t + .object('Subscribe', { + requestId: __t.u32(), + get querySetId() { + return QuerySetId; + }, + queryStrings: __t.array(__t.string()), + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + QuerySetId.serialize(writer, value.querySetId); + writer.writeU32(value.queryStrings.length); + for (const __e0 of value.queryStrings) { + writer.writeString(__e0); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = QuerySetId.deserialize(reader); + let __f2: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = reader.readString(); + } + __f2 = __arr0; + } + return { requestId: __f0, querySetId: __f1, queryStrings: __f2 }; + } + ); export type Subscribe = __Infer; -export const SubscribeApplied = __t.object('SubscribeApplied', { - requestId: __t.u32(), - get querySetId() { - return QuerySetId; - }, - get rows() { - return QueryRows; - }, -}); +export const SubscribeApplied = __t + .object('SubscribeApplied', { + requestId: __t.u32(), + get querySetId() { + return QuerySetId; + }, + get rows() { + return QueryRows; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + QuerySetId.serialize(writer, value.querySetId); + QueryRows.serialize(writer, value.rows); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = QuerySetId.deserialize(reader); + let __f2: any; + __f2 = QueryRows.deserialize(reader); + return { requestId: __f0, querySetId: __f1, rows: __f2 }; + } + ); export type SubscribeApplied = __Infer; -export const SubscriptionError = __t.object('SubscriptionError', { - requestId: __t.option(__t.u32()), - get querySetId() { - return QuerySetId; - }, - error: __t.string(), -}); +export const SubscriptionError = __t + .object('SubscriptionError', { + requestId: __t.option(__t.u32()), + get querySetId() { + return QuerySetId; + }, + error: __t.string(), + }) + .withSerde( + (writer, value: any) => { + if (value.requestId === undefined || value.requestId === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeU32(value.requestId); + } + QuerySetId.serialize(writer, value.querySetId); + writer.writeString(value.error); + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = reader.readU32(); + } else { + __f0 = undefined; + } + let __f1: any; + __f1 = QuerySetId.deserialize(reader); + let __f2: any; + __f2 = reader.readString(); + return { requestId: __f0, querySetId: __f1, error: __f2 }; + } + ); export type SubscriptionError = __Infer; -export const TableUpdate = __t.object('TableUpdate', { - tableName: __t.string(), - get rows() { - return __t.array(TableUpdateRows); - }, -}); +export const TableUpdate = __t + .object('TableUpdate', { + tableName: __t.string(), + get rows() { + return __t.array(TableUpdateRows); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeString(value.tableName); + writer.writeU32(value.rows.length); + for (const __e0 of value.rows) { + TableUpdateRows.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + let __f1: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = TableUpdateRows.deserialize(reader); + } + __f1 = __arr0; + } + return { tableName: __f0, rows: __f1 }; + } + ); export type TableUpdate = __Infer; // The tagged union or sum type for the algebraic type `TableUpdateRows`. -export const TableUpdateRows = __t.enum('TableUpdateRows', { - get PersistentTable() { - return PersistentTableRows; - }, - get EventTable() { - return EventTableRows; - }, -}); +export const TableUpdateRows = __t + .enum('TableUpdateRows', { + get PersistentTable() { + return PersistentTableRows; + }, + get EventTable() { + return EventTableRows; + }, + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'PersistentTable': { + writer.writeByte(0); + PersistentTableRows.serialize(writer, value.value); + break; + } + case 'EventTable': { + writer.writeByte(1); + EventTableRows.serialize(writer, value.value); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = PersistentTableRows.deserialize(reader); + return { tag: 'PersistentTable', value: __v }; + } + case 1: { + let __v: any; + __v = EventTableRows.deserialize(reader); + return { tag: 'EventTable', value: __v }; + } + default: { + return undefined; + } + } + } + ); export type TableUpdateRows = __Infer; -export const TransactionUpdate = __t.object('TransactionUpdate', { - get querySets() { - return __t.array(QuerySetUpdate); - }, -}); +export const TransactionUpdate = __t + .object('TransactionUpdate', { + get querySets() { + return __t.array(QuerySetUpdate); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.querySets.length); + for (const __e0 of value.querySets) { + QuerySetUpdate.serialize(writer, __e0); + } + }, + (reader): any => { + let __f0: any; + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = QuerySetUpdate.deserialize(reader); + } + __f0 = __arr0; + } + return { querySets: __f0 }; + } + ); export type TransactionUpdate = __Infer; -export const Unsubscribe = __t.object('Unsubscribe', { - requestId: __t.u32(), - get querySetId() { - return QuerySetId; - }, - get flags() { - return UnsubscribeFlags; - }, -}); +export const Unsubscribe = __t + .object('Unsubscribe', { + requestId: __t.u32(), + get querySetId() { + return QuerySetId; + }, + get flags() { + return UnsubscribeFlags; + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + QuerySetId.serialize(writer, value.querySetId); + UnsubscribeFlags.serialize(writer, value.flags); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = QuerySetId.deserialize(reader); + let __f2: any; + __f2 = UnsubscribeFlags.deserialize(reader); + return { requestId: __f0, querySetId: __f1, flags: __f2 }; + } + ); export type Unsubscribe = __Infer; -export const UnsubscribeApplied = __t.object('UnsubscribeApplied', { - requestId: __t.u32(), - get querySetId() { - return QuerySetId; - }, - get rows() { - return __t.option(QueryRows); - }, -}); +export const UnsubscribeApplied = __t + .object('UnsubscribeApplied', { + requestId: __t.u32(), + get querySetId() { + return QuerySetId; + }, + get rows() { + return __t.option(QueryRows); + }, + }) + .withSerde( + (writer, value: any) => { + writer.writeU32(value.requestId); + QuerySetId.serialize(writer, value.querySetId); + if (value.rows === undefined || value.rows === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + QueryRows.serialize(writer, value.rows); + } + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = QuerySetId.deserialize(reader); + let __f2: any; + if (reader.readByte() === 0) { + __f2 = QueryRows.deserialize(reader); + } else { + __f2 = undefined; + } + return { requestId: __f0, querySetId: __f1, rows: __f2 }; + } + ); export type UnsubscribeApplied = __Infer; // The tagged union or sum type for the algebraic type `UnsubscribeFlags`. -export const UnsubscribeFlags = __t.enum('UnsubscribeFlags', { - Default: __t.unit(), - SendDroppedRows: __t.unit(), -}); +export const UnsubscribeFlags = __t + .enum('UnsubscribeFlags', { + Default: __t.unit(), + SendDroppedRows: __t.unit(), + }) + .withSerde( + (writer, value: any) => { + switch (value.tag) { + case 'Default': { + writer.writeByte(0); + break; + } + case 'SendDroppedRows': { + writer.writeByte(1); + break; + } + default: { + throw new TypeError( + `Could not serialize sum type; unknown tag ${value.tag}` + ); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: 'Default', value: {} }; + } + case 1: { + return { tag: 'SendDroppedRows', value: {} }; + } + default: { + return undefined; + } + } + } + ); export type UnsubscribeFlags = __Infer; diff --git a/crates/bindings-typescript/src/sdk/ws.ts b/crates/bindings-typescript/src/sdk/ws.ts index 1c3172ad924..005db7389a7 100644 --- a/crates/bindings-typescript/src/sdk/ws.ts +++ b/crates/bindings-typescript/src/sdk/ws.ts @@ -7,13 +7,17 @@ async function resolveWS(): Promise { } // Node without a global WebSocket: lazily load undici's polyfill. - // Use an unstatable dynamic import so bundlers don't prebundle it. - const dynamicImport = new Function('m', 'return import(m)') as ( - m: string - ) => Promise; - + // + // We use a variable specifier plus bundler ignore-comments so build tools + // (webpack, vite/rollup, etc.) don't statically resolve `undici`. `undici` + // is declared as an optional peer dep, so it should only be loaded when + // this branch is actually reached at runtime (Node 18–21 without a global + // `WebSocket`). Browser / edge bundles never enter this branch. + const undiciSpecifier = 'undici'; try { - const { WebSocket: UndiciWS } = await dynamicImport('undici'); + const { WebSocket: UndiciWS } = (await import( + /* webpackIgnore: true */ /* @vite-ignore */ undiciSpecifier + )) as typeof import('undici'); return UndiciWS as unknown as typeof WebSocket; } catch (err) { stdbLogger( diff --git a/crates/cli/src/subcommands/generate.rs b/crates/cli/src/subcommands/generate.rs index 6e5378fede5..2ed48f334e3 100644 --- a/crates/cli/src/subcommands/generate.rs +++ b/crates/cli/src/subcommands/generate.rs @@ -301,6 +301,7 @@ fn prepare_generate_run_configs<'a>( generate_configs: Vec>, _using_config: bool, config_dir: Option<&Path>, + has_json_module: bool, ) -> anyhow::Result> { let mut runs = Vec::with_capacity(generate_configs.len()); @@ -336,7 +337,8 @@ fn prepare_generate_run_configs<'a>( } // Validate module source path for source-based generation. - if wasm_file.is_none() && js_file.is_none() && !project_path.is_dir() { + // Skip when `--module-def` is supplied, since the schema comes from JSON. + if !has_json_module && wasm_file.is_none() && js_file.is_none() && !project_path.is_dir() { anyhow::bail!( "Could not find module source at '{}'. \ If this is not correct, pass --module-path or add module-path in spacetime.json. \ @@ -638,10 +640,11 @@ pub async fn exec_ex( }; let config_dir = loaded_config_ref.map(|lc| lc.config_dir.as_path()); - let run_configs = prepare_generate_run_configs(generate_configs, using_config, config_dir)?; let json_module = args .get_many::("json_module") .map(|vals| vals.cloned().collect::>()); + let run_configs = + prepare_generate_run_configs(generate_configs, using_config, config_dir, json_module.is_some())?; let force = args.get_flag("force"); let namespace_from_cli = args.value_source("namespace") == Some(ValueSource::CommandLine); @@ -676,7 +679,7 @@ pub async fn exec_from_entries( }) .collect::, anyhow::Error>>()?; - let run_configs = prepare_generate_run_configs(generate_configs, true, config_dir)?; + let run_configs = prepare_generate_run_configs(generate_configs, true, config_dir, false)?; run_prepared_generate_configs(run_configs, extract_descriptions, None, force, false).await } @@ -976,7 +979,7 @@ mod tests { ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], false, None).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], false, None, false).unwrap(); assert_eq!(runs.len(), 1); assert_eq!(runs[0].out_dir, PathBuf::from("src/module_bindings")); } @@ -989,7 +992,7 @@ mod tests { .clone() .get_matches_from(vec!["generate", "--lang", "rust", "--bin-path", "dummy.wasm"]); let command_config = CommandConfig::new(&schema, HashMap::new(), &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], false, None).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], false, None, false).unwrap(); assert_eq!(runs[0].project_path, PathBuf::from("spacetimedb")); } @@ -1009,7 +1012,7 @@ mod tests { .unwrap(); let command_config = CommandConfig::new(&schema, HashMap::new(), &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], true, Some(config_dir.path())).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], true, Some(config_dir.path()), false).unwrap(); assert_eq!(runs[0].project_path, module_dir); assert_eq!(runs[0].out_dir, config_dir.path().join("src/module_bindings")); @@ -1038,7 +1041,7 @@ mod tests { ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], true, Some(config_dir.path())).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], true, Some(config_dir.path()), false).unwrap(); assert_eq!(runs[0].out_dir, PathBuf::from("src/module_bindings")); } @@ -1057,7 +1060,7 @@ mod tests { serde_json::Value::String(module_dir.display().to_string()), ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], false, None).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], false, None, false).unwrap(); assert_eq!(runs[0].out_dir, PathBuf::from("src/module_bindings")); } @@ -1075,7 +1078,7 @@ mod tests { serde_json::Value::String(module_dir.display().to_string()), ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], false, None).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], false, None, false).unwrap(); assert_eq!(runs[0].out_dir, PathBuf::from("module_bindings")); } @@ -1094,7 +1097,7 @@ mod tests { serde_json::Value::String(module_dir.display().to_string()), ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], true, Some(temp.path())).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], true, Some(temp.path()), false).unwrap(); assert_eq!(runs[0].lang, Language::TypeScript); assert_eq!(runs[0].out_dir, temp.path().join("src/module_bindings")); } @@ -1114,7 +1117,7 @@ mod tests { serde_json::Value::String(module_dir.display().to_string()), ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let runs = prepare_generate_run_configs(vec![command_config], true, Some(temp.path())).unwrap(); + let runs = prepare_generate_run_configs(vec![command_config], true, Some(temp.path()), false).unwrap(); assert_eq!(runs[0].lang, Language::Csharp); assert_eq!(runs[0].out_dir, temp.path().join("module_bindings")); } @@ -1125,7 +1128,7 @@ mod tests { let schema = build_generate_config_schema(&cmd).unwrap(); let matches = cmd.clone().get_matches_from(vec!["generate"]); let command_config = CommandConfig::new(&schema, HashMap::new(), &matches).unwrap(); - let err = prepare_generate_run_configs(vec![command_config], false, None).unwrap_err(); + let err = prepare_generate_run_configs(vec![command_config], false, None, false).unwrap_err(); let msg = err.to_string(); assert!(msg.contains("Could not find module source at 'spacetimedb'")); assert!(msg.contains("--module-path")); @@ -1146,7 +1149,7 @@ mod tests { serde_json::Value::String(module_dir.display().to_string()), ); let command_config = CommandConfig::new(&schema, cfg, &matches).unwrap(); - let err = prepare_generate_run_configs(vec![command_config], true, Some(temp.path())).unwrap_err(); + let err = prepare_generate_run_configs(vec![command_config], true, Some(temp.path()), false).unwrap_err(); let msg = err.to_string(); assert!(msg.contains("Could not auto-detect client language")); assert!(msg.contains("--lang")); diff --git a/crates/codegen/src/typescript.rs b/crates/codegen/src/typescript.rs index 28bc1fb4c91..8178974426a 100644 --- a/crates/codegen/src/typescript.rs +++ b/crates/codegen/src/typescript.rs @@ -83,7 +83,8 @@ impl Lang for TypeScript { out.indent(1); write_object_type_builder_fields(module, out, &product_def.elements, table.primary_key, true, true).unwrap(); out.dedent(1); - writeln!(out, "}});"); + write!(out, "}})"); + write_product_with_serde(module, out, &product_def.elements, /* convert_case */ true); OutputFile { filename: table_module_name(&table.accessor_name) + ".ts", code: output.into_inner(), @@ -520,6 +521,10 @@ fn print_index_imports(out: &mut Indenter) { let mut types = [ "TypeBuilder as __TypeBuilder", "type AlgebraicTypeType as __AlgebraicTypeType", + "ConnectionId as __ConnectionId", + "Identity as __Identity", + "TimeDuration as __TimeDuration", + "Timestamp as __Timestamp", "Uuid as __Uuid", "DbConnectionBuilder as __DbConnectionBuilder", "convertToAccessorMap as __convertToAccessorMap", @@ -560,6 +565,11 @@ fn print_type_builder_imports(out: &mut Indenter) { let mut types = [ "TypeBuilder as __TypeBuilder", "type AlgebraicTypeType as __AlgebraicTypeType", + "ConnectionId as __ConnectionId", + "Identity as __Identity", + "TimeDuration as __TimeDuration", + "Timestamp as __Timestamp", + "Uuid as __Uuid", "type Infer as __Infer", "t as __t", ]; @@ -616,7 +626,18 @@ fn define_body_for_reducer(module: &ModuleDef, out: &mut Indenter, params: &[(Id /// x: __t.f32(), /// y: __t.f32(), /// fooBar: __t.string(), -/// }); +/// }).withSerde( +/// (writer, value) => { +/// writer.writeF32(value.x); +/// writer.writeF32(value.y); +/// writer.writeString(value.fooBar); +/// }, +/// reader => ({ +/// x: reader.readF32(), +/// y: reader.readF32(), +/// fooBar: reader.readString(), +/// }) +/// ); /// export type Point = __Infer; /// ``` fn define_body_for_product( @@ -627,12 +648,13 @@ fn define_body_for_product( ) { write!(out, "export const {name} = __t.object(\"{name}\", {{"); if elements.is_empty() { - writeln!(out, "}});"); + write!(out, "}})"); } else { writeln!(out); out.with_indent(|out| write_object_type_builder_fields(module, out, elements, None, true, false).unwrap()); - writeln!(out, "}});"); + write!(out, "}})"); } + write_product_with_serde(module, out, elements, /* convert_case */ true); writeln!(out, "export type {name} = __Infer;"); out.newline(); } @@ -844,6 +866,473 @@ fn write_type_builder(module: &ModuleDef, out: &mut W, ty: &AlgebraicT Ok(()) } +/// Counter used to mint unique temporary variable names while emitting +/// static serializers/deserializers for nested types (e.g. arrays, results). +/// Each emitted top-level function gets its own counter. +#[derive(Default)] +struct TempCounter(u32); + +impl TempCounter { + fn next(&mut self) -> u32 { + let n = self.0; + self.0 += 1; + n + } +} + +fn primitive_write_method(p: &PrimitiveType) -> &'static str { + match p { + PrimitiveType::Bool => "writeBool", + PrimitiveType::I8 => "writeI8", + PrimitiveType::U8 => "writeU8", + PrimitiveType::I16 => "writeI16", + PrimitiveType::U16 => "writeU16", + PrimitiveType::I32 => "writeI32", + PrimitiveType::U32 => "writeU32", + PrimitiveType::I64 => "writeI64", + PrimitiveType::U64 => "writeU64", + PrimitiveType::I128 => "writeI128", + PrimitiveType::U128 => "writeU128", + PrimitiveType::I256 => "writeI256", + PrimitiveType::U256 => "writeU256", + PrimitiveType::F32 => "writeF32", + PrimitiveType::F64 => "writeF64", + } +} + +fn primitive_read_method(p: &PrimitiveType) -> &'static str { + match p { + PrimitiveType::Bool => "readBool", + PrimitiveType::I8 => "readI8", + PrimitiveType::U8 => "readU8", + PrimitiveType::I16 => "readI16", + PrimitiveType::U16 => "readU16", + PrimitiveType::I32 => "readI32", + PrimitiveType::U32 => "readU32", + PrimitiveType::I64 => "readI64", + PrimitiveType::U64 => "readU64", + PrimitiveType::I128 => "readI128", + PrimitiveType::U128 => "readU128", + PrimitiveType::I256 => "readI256", + PrimitiveType::U256 => "readU256", + PrimitiveType::F32 => "readF32", + PrimitiveType::F64 => "readF64", + } +} + +/// Emit JS statements that serialize the value at `value_expr` (which has type +/// `ty`) into the in-scope `writer`. Used to bake static serializers into +/// generated TypeScript, removing the need for runtime `Function(...)` codegen. +fn write_serialize_value( + module: &ModuleDef, + out: &mut Indenter, + ty: &AlgebraicTypeUse, + value_expr: &str, + counter: &mut TempCounter, +) { + match ty { + AlgebraicTypeUse::Unit => { + // Nothing to write on the wire for unit. + } + AlgebraicTypeUse::Never => { + writeln!(out, "throw new TypeError(\"Cannot serialize a value of type `never`\");"); + } + AlgebraicTypeUse::Primitive(prim) => { + let m = primitive_write_method(prim); + writeln!(out, "writer.{m}({value_expr});"); + } + AlgebraicTypeUse::String => { + writeln!(out, "writer.writeString({value_expr});"); + } + AlgebraicTypeUse::Identity => { + writeln!(out, "writer.writeU256({value_expr}.__identity__);"); + } + AlgebraicTypeUse::ConnectionId => { + writeln!(out, "writer.writeU128({value_expr}.__connection_id__);"); + } + AlgebraicTypeUse::Timestamp => { + writeln!( + out, + "writer.writeI64({value_expr}.__timestamp_micros_since_unix_epoch__);" + ); + } + AlgebraicTypeUse::TimeDuration => { + writeln!(out, "writer.writeI64({value_expr}.__time_duration_micros__);"); + } + AlgebraicTypeUse::Uuid => { + writeln!(out, "writer.writeU128({value_expr}.__uuid__);"); + } + AlgebraicTypeUse::ScheduleAt => { + writeln!(out, "if ({value_expr}.tag === \"Interval\") {{"); + out.indent(1); + writeln!(out, "writer.writeByte(0);"); + writeln!( + out, + "writer.writeI64({value_expr}.value.__time_duration_micros__);" + ); + out.dedent(1); + writeln!(out, "}} else {{"); + out.indent(1); + writeln!(out, "writer.writeByte(1);"); + writeln!( + out, + "writer.writeI64({value_expr}.value.__timestamp_micros_since_unix_epoch__);" + ); + out.dedent(1); + writeln!(out, "}}"); + } + AlgebraicTypeUse::Option(inner_ty) => { + writeln!( + out, + "if ({value_expr} === undefined || {value_expr} === null) {{" + ); + out.indent(1); + writeln!(out, "writer.writeByte(1);"); + out.dedent(1); + writeln!(out, "}} else {{"); + out.indent(1); + writeln!(out, "writer.writeByte(0);"); + write_serialize_value(module, out, inner_ty, value_expr, counter); + out.dedent(1); + writeln!(out, "}}"); + } + AlgebraicTypeUse::Result { ok_ty, err_ty } => { + writeln!(out, "if (\"ok\" in {value_expr}) {{"); + out.indent(1); + writeln!(out, "writer.writeByte(0);"); + write_serialize_value(module, out, ok_ty, &format!("{value_expr}.ok"), counter); + out.dedent(1); + writeln!(out, "}} else {{"); + out.indent(1); + writeln!(out, "writer.writeByte(1);"); + write_serialize_value(module, out, err_ty, &format!("{value_expr}.err"), counter); + out.dedent(1); + writeln!(out, "}}"); + } + AlgebraicTypeUse::Array(elem_ty) => { + if matches!(&**elem_ty, AlgebraicTypeUse::Primitive(PrimitiveType::U8)) { + writeln!(out, "writer.writeUInt8Array({value_expr});"); + } else { + let n = counter.next(); + let elem_var = format!("__e{n}"); + writeln!(out, "writer.writeU32({value_expr}.length);"); + writeln!(out, "for (const {elem_var} of {value_expr}) {{"); + out.indent(1); + write_serialize_value(module, out, elem_ty, &elem_var, counter); + out.dedent(1); + writeln!(out, "}}"); + } + } + AlgebraicTypeUse::Ref(r) => { + let name = type_ref_name(module, *r); + writeln!(out, "{name}.serialize(writer, {value_expr});"); + } + } +} + +/// Emit JS statements that read a value of type `ty` from the in-scope `reader` +/// and assign it to `target` (a JS lvalue, e.g. `__x` or `__arr[__i]`). +fn write_deserialize_into( + module: &ModuleDef, + out: &mut Indenter, + ty: &AlgebraicTypeUse, + target: &str, + counter: &mut TempCounter, +) { + match ty { + AlgebraicTypeUse::Unit => { + writeln!(out, "{target} = {{}};"); + } + AlgebraicTypeUse::Never => { + writeln!(out, "throw new TypeError(\"Cannot deserialize a value of type `never`\");"); + } + AlgebraicTypeUse::Primitive(prim) => { + let m = primitive_read_method(prim); + writeln!(out, "{target} = reader.{m}();"); + } + AlgebraicTypeUse::String => { + writeln!(out, "{target} = reader.readString();"); + } + AlgebraicTypeUse::Identity => { + writeln!(out, "{target} = new __Identity(reader.readU256());"); + } + AlgebraicTypeUse::ConnectionId => { + writeln!(out, "{target} = new __ConnectionId(reader.readU128());"); + } + AlgebraicTypeUse::Timestamp => { + writeln!(out, "{target} = new __Timestamp(reader.readI64());"); + } + AlgebraicTypeUse::TimeDuration => { + writeln!(out, "{target} = new __TimeDuration(reader.readI64());"); + } + AlgebraicTypeUse::Uuid => { + writeln!(out, "{target} = new __Uuid(reader.readU128());"); + } + AlgebraicTypeUse::ScheduleAt => { + let n = counter.next(); + let tag_var = format!("__tag{n}"); + writeln!(out, "{{"); + out.indent(1); + writeln!(out, "const {tag_var} = reader.readByte();"); + writeln!(out, "if ({tag_var} === 0) {{"); + out.indent(1); + writeln!( + out, + "{target} = {{ tag: \"Interval\", value: new __TimeDuration(reader.readI64()) }};" + ); + out.dedent(1); + writeln!(out, "}} else if ({tag_var} === 1) {{"); + out.indent(1); + writeln!( + out, + "{target} = {{ tag: \"Time\", value: new __Timestamp(reader.readI64()) }};" + ); + out.dedent(1); + writeln!(out, "}} else {{"); + out.indent(1); + writeln!( + out, + "throw new TypeError(`Could not deserialize ScheduleAt; unknown tag ${{{tag_var}}}`);" + ); + out.dedent(1); + writeln!(out, "}}"); + out.dedent(1); + writeln!(out, "}}"); + } + AlgebraicTypeUse::Option(inner_ty) => { + writeln!(out, "if (reader.readByte() === 0) {{"); + out.indent(1); + write_deserialize_into(module, out, inner_ty, target, counter); + out.dedent(1); + writeln!(out, "}} else {{"); + out.indent(1); + writeln!(out, "{target} = undefined;"); + out.dedent(1); + writeln!(out, "}}"); + } + AlgebraicTypeUse::Result { ok_ty, err_ty } => { + let n = counter.next(); + let tag_var = format!("__tag{n}"); + let inner_var = format!("__r{n}"); + writeln!(out, "{{"); + out.indent(1); + writeln!(out, "const {tag_var} = reader.readByte();"); + writeln!(out, "if ({tag_var} === 0) {{"); + out.indent(1); + writeln!(out, "let {inner_var}: any;"); + write_deserialize_into(module, out, ok_ty, &inner_var, counter); + writeln!(out, "{target} = {{ ok: {inner_var} }};"); + out.dedent(1); + writeln!(out, "}} else {{"); + out.indent(1); + writeln!(out, "let {inner_var}: any;"); + write_deserialize_into(module, out, err_ty, &inner_var, counter); + writeln!(out, "{target} = {{ err: {inner_var} }};"); + out.dedent(1); + writeln!(out, "}}"); + out.dedent(1); + writeln!(out, "}}"); + } + AlgebraicTypeUse::Array(elem_ty) => { + if matches!(&**elem_ty, AlgebraicTypeUse::Primitive(PrimitiveType::U8)) { + writeln!(out, "{target} = reader.readUInt8Array();"); + } else { + let n = counter.next(); + let len_var = format!("__len{n}"); + let arr_var = format!("__arr{n}"); + let i_var = format!("__i{n}"); + writeln!(out, "{{"); + out.indent(1); + writeln!(out, "const {len_var} = reader.readU32();"); + writeln!(out, "const {arr_var}: any[] = new Array({len_var});"); + writeln!(out, "for (let {i_var} = 0; {i_var} < {len_var}; {i_var}++) {{"); + out.indent(1); + write_deserialize_into(module, out, elem_ty, &format!("{arr_var}[{i_var}]"), counter); + out.dedent(1); + writeln!(out, "}}"); + writeln!(out, "{target} = {arr_var};"); + out.dedent(1); + writeln!(out, "}}"); + } + } + AlgebraicTypeUse::Ref(r) => { + let name = type_ref_name(module, *r); + writeln!(out, "{target} = {name}.deserialize(reader);"); + } + } +} + +/// Emit a `.withSerde(...)` call appended to a product-type expression. This +/// installs static serialize/deserialize functions on the generated +/// `__t.object(...)` / `__t.row(...)` builder, replacing the runtime +/// closure-based tree walker for these named types. +fn write_product_with_serde( + module: &ModuleDef, + out: &mut Indenter, + elements: &[(Identifier, AlgebraicTypeUse)], + convert_case: bool, +) { + if elements.is_empty() { + // No-op serializer/deserializer for empty products. Match the existing + // runtime fast path (`unitDeserializer`) by returning `{}`. + writeln!(out, ".withSerde("); + out.indent(1); + writeln!(out, "() => {{}},"); + writeln!(out, "() => ({{}}) as any"); + out.dedent(1); + writeln!(out, ");"); + return; + } + + let field_names: Vec = elements + .iter() + .map(|(ident, _)| { + if convert_case { + ident.deref().to_case(Case::Camel) + } else { + ident.deref().to_string() + } + }) + .collect(); + + writeln!(out, ".withSerde("); + out.indent(1); + + // Serializer. `value: any` because (a) generated code knows the wire + // shape, and (b) some inferred TS types (e.g. `Result` ↦ `T | E`) + // do not match the runtime representation (`{ok}|{err}`) the wire uses. + let mut serializer_counter = TempCounter::default(); + writeln!(out, "(writer, value: any) => {{"); + out.indent(1); + for (i, (_ident, ty)) in elements.iter().enumerate() { + let field = &field_names[i]; + let access = js_property_access("value", field); + write_serialize_value(module, out, ty, &access, &mut serializer_counter); + } + out.dedent(1); + writeln!(out, "}},"); + + // Deserializer. + let mut deserializer_counter = TempCounter::default(); + writeln!(out, "(reader): any => {{"); + out.indent(1); + for (i, (_ident, ty)) in elements.iter().enumerate() { + let temp = format!("__f{i}"); + writeln!(out, "let {temp}: any;"); + write_deserialize_into(module, out, ty, &temp, &mut deserializer_counter); + } + write!(out, "return {{ "); + for (i, field) in field_names.iter().enumerate() { + if i > 0 { + write!(out, ", "); + } + // Quote the key so JS reserved words (e.g. `default`) are accepted. + write!(out, "{:?}: __f{i}", field); + } + writeln!(out, " }};"); + out.dedent(1); + writeln!(out, "}}"); + + out.dedent(1); + writeln!(out, ");"); +} + +/// Emit a `.withSerde(...)` call appended to a sum-type expression. Variant +/// names must already be in their final (tag) form as they will appear in JS +/// `value.tag` (codegen pascal-cases them). +fn write_sum_with_serde( + module: &ModuleDef, + out: &mut Indenter, + variants: &[(Identifier, AlgebraicTypeUse)], +) { + writeln!(out, ".withSerde("); + out.indent(1); + + // Serializer. See `write_product_with_serde` for why we use `any` here. + let mut serializer_counter = TempCounter::default(); + writeln!(out, "(writer, value: any) => {{"); + out.indent(1); + writeln!(out, "switch (value.tag) {{"); + for (i, (ident, ty)) in variants.iter().enumerate() { + let tag = ident.deref().to_string(); + writeln!(out, "case {tag:?}: {{"); + out.indent(1); + writeln!(out, "writer.writeByte({i});"); + if !matches!(ty, AlgebraicTypeUse::Unit) { + write_serialize_value(module, out, ty, "value.value", &mut serializer_counter); + } + writeln!(out, "break;"); + out.dedent(1); + writeln!(out, "}}"); + } + writeln!(out, "default: {{"); + out.indent(1); + writeln!( + out, + "throw new TypeError(`Could not serialize sum type; unknown tag ${{value.tag}}`);" + ); + out.dedent(1); + writeln!(out, "}}"); + writeln!(out, "}}"); + out.dedent(1); + writeln!(out, "}},"); + + // Deserializer. + let mut deserializer_counter = TempCounter::default(); + writeln!(out, "(reader): any => {{"); + out.indent(1); + writeln!(out, "switch (reader.readByte()) {{"); + for (i, (ident, ty)) in variants.iter().enumerate() { + let tag = ident.deref().to_string(); + writeln!(out, "case {i}: {{"); + out.indent(1); + if matches!(ty, AlgebraicTypeUse::Unit) { + // Mirror the runtime tree walker, which wraps unit variants as + // `{ tag, value: {} }` for uniformity with non-unit variants. + writeln!(out, "return {{ tag: {tag:?}, value: {{}} }};"); + } else { + writeln!(out, "let __v: any;"); + write_deserialize_into(module, out, ty, "__v", &mut deserializer_counter); + writeln!(out, "return {{ tag: {tag:?}, value: __v }};"); + } + out.dedent(1); + writeln!(out, "}}"); + } + writeln!(out, "default: {{"); + out.indent(1); + // Preserve the runtime tree walker's behavior of returning `undefined` for + // out-of-range tags. (Some callers may rely on this.) + writeln!(out, "return undefined;"); + out.dedent(1); + writeln!(out, "}}"); + writeln!(out, "}}"); + out.dedent(1); + writeln!(out, "}}"); + + out.dedent(1); + writeln!(out, ");"); +} + +/// Render a JS property access expression. Prefers dot-notation when the +/// property name is a valid JS identifier, otherwise falls back to bracket +/// notation with a quoted key. +fn js_property_access(base: &str, property: &str) -> String { + if is_valid_js_identifier(property) { + format!("{base}.{property}") + } else { + format!("{base}[{property:?}]") + } +} + +fn is_valid_js_identifier(s: &str) -> bool { + let mut chars = s.chars(); + match chars.next() { + Some(c) if c.is_ascii_alphabetic() || c == '_' || c == '$' => {} + _ => return false, + } + chars.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '$') +} + /// e.g. /// ```ts /// // The tagged union or sum type for the algebraic type `Option`. @@ -874,7 +1363,8 @@ fn define_body_for_sum( }) .collect(); out.with_indent(|out| write_object_type_builder_fields(module, out, &pascal_variants, None, false, false).unwrap()); - writeln!(out, "}});"); + write!(out, "}})"); + write_sum_with_serde(module, out, &pascal_variants); writeln!(out, "export type {name} = __Infer;"); out.newline(); } diff --git a/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap b/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap index ecfe6755357..82185534de1 100644 --- a/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap +++ b/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap @@ -9,7 +9,12 @@ expression: outfiles /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -26,7 +31,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -43,7 +53,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -61,7 +76,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -76,7 +96,12 @@ export default {}; /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -93,7 +118,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -110,7 +140,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -128,9 +163,13 @@ VERSION_COMMENT /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, DbConnectionBuilder as __DbConnectionBuilder, DbConnectionImpl as __DbConnectionImpl, + Identity as __Identity, SubscriptionBuilderImpl as __SubscriptionBuilderImpl, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, Uuid as __Uuid, convertToAccessorMap as __convertToAccessorMap, @@ -347,7 +386,12 @@ export class DbConnection extends __DbConnectionImpl { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -364,7 +408,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -379,7 +428,12 @@ export default {}; /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -389,7 +443,22 @@ export default __t.row({ identity: __t.identity().primaryKey(), playerId: __t.u64().name("player_id"), name: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU256(value.identity.__identity__); + writer.writeU64(value.playerId); + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + __f0 = new __Identity(reader.readU256()); + let __f1: any; + __f1 = reader.readU64(); + let __f2: any; + __f2 = reader.readString(); + return { "identity": __f0, "playerId": __f1, "name": __f2 }; + } +); ''' "my_player_table.ts" = ''' // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE @@ -398,7 +467,12 @@ export default __t.row({ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -408,7 +482,22 @@ export default __t.row({ identity: __t.identity(), playerId: __t.u64().name("player_id"), name: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU256(value.identity.__identity__); + writer.writeU64(value.playerId); + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + __f0 = new __Identity(reader.readU256()); + let __f1: any; + __f1 = reader.readU64(); + let __f2: any; + __f2 = reader.readString(); + return { "identity": __f0, "playerId": __f1, "name": __f2 }; + } +); ''' "person_table.ts" = ''' // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE @@ -417,7 +506,12 @@ export default __t.row({ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -427,7 +521,22 @@ export default __t.row({ id: __t.u32().primaryKey(), name: __t.string(), age: __t.u8(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU32(value.id); + writer.writeString(value.name); + writer.writeU8(value.age); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readString(); + let __f2: any; + __f2 = reader.readU8(); + return { "id": __f0, "name": __f1, "age": __f2 }; + } +); ''' "player_table.ts" = ''' // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE @@ -436,7 +545,12 @@ export default __t.row({ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -446,7 +560,22 @@ export default __t.row({ identity: __t.identity().primaryKey(), playerId: __t.u64().name("player_id"), name: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU256(value.identity.__identity__); + writer.writeU64(value.playerId); + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + __f0 = new __Identity(reader.readU256()); + let __f1: any; + __f1 = reader.readU64(); + let __f2: any; + __f2 = reader.readString(); + return { "identity": __f0, "playerId": __f1, "name": __f2 }; + } +); ''' "query_private_reducer.ts" = ''' // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE @@ -455,7 +584,12 @@ export default __t.row({ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -470,7 +604,12 @@ export default {}; /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -491,7 +630,12 @@ export const returnType = Baz''' /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -506,7 +650,12 @@ export default {}; /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -522,7 +671,12 @@ export const returnType = __t.unit()''' /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -537,7 +691,12 @@ export default {}; /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -554,7 +713,47 @@ export default __t.row({ get testCNested() { return __t.option(__t.array(NamespaceTestC)).name("test_c_nested"); }, -}); +}).withSerde( + (writer, value: any) => { + if (value.testC === undefined || value.testC === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + NamespaceTestC.serialize(writer, value.testC); + } + if (value.testCNested === undefined || value.testCNested === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeU32(value.testCNested.length); + for (const __e0 of value.testCNested) { + NamespaceTestC.serialize(writer, __e0); + } + } + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = NamespaceTestC.deserialize(reader); + } else { + __f0 = undefined; + } + let __f1: any; + if (reader.readByte() === 0) { + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = NamespaceTestC.deserialize(reader); + } + __f1 = __arr0; + } + } else { + __f1 = undefined; + } + return { "testC": __f0, "testCNested": __f1 }; + } +); ''' "test_f_table.ts" = ''' // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE @@ -563,7 +762,12 @@ export default __t.row({ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -577,7 +781,16 @@ export default __t.row({ get field() { return Foobar; }, -}); +}).withSerde( + (writer, value: any) => { + Foobar.serialize(writer, value.field); + }, + (reader): any => { + let __f0: any; + __f0 = Foobar.deserialize(reader); + return { "field": __f0 }; + } +); ''' "test_reducer.ts" = ''' // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE @@ -586,7 +799,12 @@ export default __t.row({ /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -621,7 +839,12 @@ export default { /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer, @@ -629,7 +852,16 @@ import { export const Baz = __t.object("Baz", { field: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeString(value.field); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + return { "field": __f0 }; + } +); export type Baz = __Infer; // The tagged union or sum type for the algebraic type `Foobar`. @@ -639,75 +871,285 @@ export const Foobar = __t.enum("Foobar", { }, Bar: __t.unit(), Har: __t.u32(), -}); +}).withSerde( + (writer, value: any) => { + switch (value.tag) { + case "Baz": { + writer.writeByte(0); + Baz.serialize(writer, value.value); + break; + } + case "Bar": { + writer.writeByte(1); + break; + } + case "Har": { + writer.writeByte(2); + writer.writeU32(value.value); + break; + } + default: { + throw new TypeError(`Could not serialize sum type; unknown tag ${value.tag}`); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + let __v: any; + __v = Baz.deserialize(reader); + return { tag: "Baz", value: __v }; + } + case 1: { + return { tag: "Bar", value: {} }; + } + case 2: { + let __v: any; + __v = reader.readU32(); + return { tag: "Har", value: __v }; + } + default: { + return undefined; + } + } + } +); export type Foobar = __Infer; export const HasSpecialStuff = __t.object("HasSpecialStuff", { identity: __t.identity(), connectionId: __t.connectionId(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU256(value.identity.__identity__); + writer.writeU128(value.connectionId.__connection_id__); + }, + (reader): any => { + let __f0: any; + __f0 = new __Identity(reader.readU256()); + let __f1: any; + __f1 = new __ConnectionId(reader.readU128()); + return { "identity": __f0, "connectionId": __f1 }; + } +); export type HasSpecialStuff = __Infer; export const NonrepeatingTestArg = __t.object("NonrepeatingTestArg", { scheduledId: __t.u64(), scheduledAt: __t.scheduleAt(), prevTime: __t.timestamp(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU64(value.scheduledId); + if (value.scheduledAt.tag === "Interval") { + writer.writeByte(0); + writer.writeI64(value.scheduledAt.value.__time_duration_micros__); + } else { + writer.writeByte(1); + writer.writeI64(value.scheduledAt.value.__timestamp_micros_since_unix_epoch__); + } + writer.writeI64(value.prevTime.__timestamp_micros_since_unix_epoch__); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU64(); + let __f1: any; + { + const __tag0 = reader.readByte(); + if (__tag0 === 0) { + __f1 = { tag: "Interval", value: new __TimeDuration(reader.readI64()) }; + } else if (__tag0 === 1) { + __f1 = { tag: "Time", value: new __Timestamp(reader.readI64()) }; + } else { + throw new TypeError(`Could not deserialize ScheduleAt; unknown tag ${__tag0}`); + } + } + let __f2: any; + __f2 = new __Timestamp(reader.readI64()); + return { "scheduledId": __f0, "scheduledAt": __f1, "prevTime": __f2 }; + } +); export type NonrepeatingTestArg = __Infer; export const Person = __t.object("Person", { id: __t.u32(), name: __t.string(), age: __t.u8(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU32(value.id); + writer.writeString(value.name); + writer.writeU8(value.age); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readString(); + let __f2: any; + __f2 = reader.readU8(); + return { "id": __f0, "name": __f1, "age": __f2 }; + } +); export type Person = __Infer; export const PkMultiIdentity = __t.object("PkMultiIdentity", { id: __t.u32(), other: __t.u32(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU32(value.id); + writer.writeU32(value.other); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readU32(); + return { "id": __f0, "other": __f1 }; + } +); export type PkMultiIdentity = __Infer; export const Player = __t.object("Player", { identity: __t.identity(), playerId: __t.u64(), name: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU256(value.identity.__identity__); + writer.writeU64(value.playerId); + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + __f0 = new __Identity(reader.readU256()); + let __f1: any; + __f1 = reader.readU64(); + let __f2: any; + __f2 = reader.readString(); + return { "identity": __f0, "playerId": __f1, "name": __f2 }; + } +); export type Player = __Infer; export const Point = __t.object("Point", { x: __t.i64(), y: __t.i64(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeI64(value.x); + writer.writeI64(value.y); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readI64(); + let __f1: any; + __f1 = reader.readI64(); + return { "x": __f0, "y": __f1 }; + } +); export type Point = __Infer; export const PrivateTable = __t.object("PrivateTable", { name: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + return { "name": __f0 }; + } +); export type PrivateTable = __Infer; export const RemoveTable = __t.object("RemoveTable", { id: __t.u32(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU32(value.id); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + return { "id": __f0 }; + } +); export type RemoveTable = __Infer; export const RepeatingTestArg = __t.object("RepeatingTestArg", { scheduledId: __t.u64(), scheduledAt: __t.scheduleAt(), prevTime: __t.timestamp(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU64(value.scheduledId); + if (value.scheduledAt.tag === "Interval") { + writer.writeByte(0); + writer.writeI64(value.scheduledAt.value.__time_duration_micros__); + } else { + writer.writeByte(1); + writer.writeI64(value.scheduledAt.value.__timestamp_micros_since_unix_epoch__); + } + writer.writeI64(value.prevTime.__timestamp_micros_since_unix_epoch__); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU64(); + let __f1: any; + { + const __tag0 = reader.readByte(); + if (__tag0 === 0) { + __f1 = { tag: "Interval", value: new __TimeDuration(reader.readI64()) }; + } else if (__tag0 === 1) { + __f1 = { tag: "Time", value: new __Timestamp(reader.readI64()) }; + } else { + throw new TypeError(`Could not deserialize ScheduleAt; unknown tag ${__tag0}`); + } + } + let __f2: any; + __f2 = new __Timestamp(reader.readI64()); + return { "scheduledId": __f0, "scheduledAt": __f1, "prevTime": __f2 }; + } +); export type RepeatingTestArg = __Infer; export const TestA = __t.object("TestA", { x: __t.u32(), y: __t.u32(), z: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU32(value.x); + writer.writeU32(value.y); + writer.writeString(value.z); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU32(); + let __f1: any; + __f1 = reader.readU32(); + let __f2: any; + __f2 = reader.readString(); + return { "x": __f0, "y": __f1, "z": __f2 }; + } +); export type TestA = __Infer; export const TestB = __t.object("TestB", { foo: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeString(value.foo); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readString(); + return { "foo": __f0 }; + } +); export type TestB = __Infer; export const TestD = __t.object("TestD", { @@ -717,27 +1159,117 @@ export const TestD = __t.object("TestD", { get testCNested() { return __t.option(__t.array(NamespaceTestC)); }, -}); +}).withSerde( + (writer, value: any) => { + if (value.testC === undefined || value.testC === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + NamespaceTestC.serialize(writer, value.testC); + } + if (value.testCNested === undefined || value.testCNested === null) { + writer.writeByte(1); + } else { + writer.writeByte(0); + writer.writeU32(value.testCNested.length); + for (const __e0 of value.testCNested) { + NamespaceTestC.serialize(writer, __e0); + } + } + }, + (reader): any => { + let __f0: any; + if (reader.readByte() === 0) { + __f0 = NamespaceTestC.deserialize(reader); + } else { + __f0 = undefined; + } + let __f1: any; + if (reader.readByte() === 0) { + { + const __len0 = reader.readU32(); + const __arr0: any[] = new Array(__len0); + for (let __i0 = 0; __i0 < __len0; __i0++) { + __arr0[__i0] = NamespaceTestC.deserialize(reader); + } + __f1 = __arr0; + } + } else { + __f1 = undefined; + } + return { "testC": __f0, "testCNested": __f1 }; + } +); export type TestD = __Infer; export const TestE = __t.object("TestE", { id: __t.u64(), name: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + writer.writeU64(value.id); + writer.writeString(value.name); + }, + (reader): any => { + let __f0: any; + __f0 = reader.readU64(); + let __f1: any; + __f1 = reader.readString(); + return { "id": __f0, "name": __f1 }; + } +); export type TestE = __Infer; export const TestFoobar = __t.object("TestFoobar", { get field() { return Foobar; }, -}); +}).withSerde( + (writer, value: any) => { + Foobar.serialize(writer, value.field); + }, + (reader): any => { + let __f0: any; + __f0 = Foobar.deserialize(reader); + return { "field": __f0 }; + } +); export type TestFoobar = __Infer; // The tagged union or sum type for the algebraic type `NamespaceTestC`. export const NamespaceTestC = __t.enum("NamespaceTestC", { Foo: __t.unit(), Bar: __t.unit(), -}); +}).withSerde( + (writer, value: any) => { + switch (value.tag) { + case "Foo": { + writer.writeByte(0); + break; + } + case "Bar": { + writer.writeByte(1); + break; + } + default: { + throw new TypeError(`Could not serialize sum type; unknown tag ${value.tag}`); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: "Foo", value: {} }; + } + case 1: { + return { tag: "Bar", value: {} }; + } + default: { + return undefined; + } + } + } +); export type NamespaceTestC = __Infer; // The tagged union or sum type for the algebraic type `NamespaceTestF`. @@ -745,7 +1277,46 @@ export const NamespaceTestF = __t.enum("NamespaceTestF", { Foo: __t.unit(), Bar: __t.unit(), Baz: __t.string(), -}); +}).withSerde( + (writer, value: any) => { + switch (value.tag) { + case "Foo": { + writer.writeByte(0); + break; + } + case "Bar": { + writer.writeByte(1); + break; + } + case "Baz": { + writer.writeByte(2); + writer.writeString(value.value); + break; + } + default: { + throw new TypeError(`Could not serialize sum type; unknown tag ${value.tag}`); + } + } + }, + (reader): any => { + switch (reader.readByte()) { + case 0: { + return { tag: "Foo", value: {} }; + } + case 1: { + return { tag: "Bar", value: {} }; + } + case 2: { + let __v: any; + __v = reader.readString(); + return { tag: "Baz", value: __v }; + } + default: { + return undefined; + } + } + } +); export type NamespaceTestF = __Infer; ''' @@ -816,7 +1387,12 @@ export type TestBtreeIndexArgsParams = __Infer /* eslint-disable */ /* tslint:disable */ import { + ConnectionId as __ConnectionId, + Identity as __Identity, + TimeDuration as __TimeDuration, + Timestamp as __Timestamp, TypeBuilder as __TypeBuilder, + Uuid as __Uuid, t as __t, type AlgebraicTypeType as __AlgebraicTypeType, type Infer as __Infer,