tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/clients/node/node_bindings.zig

@@ -1,267 +0,0 @@
-const std = @import("std");
-const vsr = @import("vsr");
-
-const assert = std.debug.assert;
-const tb = vsr.tigerbeetle;
-const tb_client = vsr.tb_client;
-
-const TypeMapping = struct {
-    name: []const u8,
-    hidden_fields: []const []const u8 = &.{},
-    docs_link: ?[]const u8 = null,
-
-    pub fn hidden(comptime self: @This(), name: []const u8) bool {
-        inline for (self.hidden_fields) |field| {
-            if (std.mem.eql(u8, field, name)) {
-                return true;
-            }
-        } else return false;
-    }
-};
-
-const type_mappings = .{
-    .{ tb.AccountFlags, TypeMapping{
-        .name = "AccountFlags",
-        .hidden_fields = &.{"padding"},
-        .docs_link = "reference/account#flags",
-    } },
-    .{ tb.TransferFlags, TypeMapping{
-        .name = "TransferFlags",
-        .hidden_fields = &.{"padding"},
-        .docs_link = "reference/transfer#flags",
-    } },
-    .{ tb.AccountFilterFlags, TypeMapping{
-        .name = "AccountFilterFlags",
-        .hidden_fields = &.{"padding"},
-        .docs_link = "reference/account-filter#flags",
-    } },
-    .{ tb.QueryFilterFlags, TypeMapping{
-        .name = "QueryFilterFlags",
-        .hidden_fields = &.{"padding"},
-        .docs_link = "reference/query-filter#flags",
-    } },
-    .{ tb.Account, TypeMapping{
-        .name = "Account",
-        .docs_link = "reference/account/#",
-    } },
-    .{ tb.Transfer, TypeMapping{
-        .name = "Transfer",
-        .docs_link = "reference/transfer/#",
-    } },
-    .{ tb.CreateAccountResult, TypeMapping{
-        .name = "CreateAccountError",
-        .docs_link = "reference/requests/create_accounts#",
-    } },
-    .{ tb.CreateTransferResult, TypeMapping{
-        .name = "CreateTransferError",
-        .docs_link = "reference/requests/create_transfers#",
-    } },
-    .{ tb.CreateAccountsResult, TypeMapping{
-        .name = "CreateAccountsError",
-    } },
-    .{ tb.CreateTransfersResult, TypeMapping{
-        .name = "CreateTransfersError",
-    } },
-    .{ tb.AccountFilter, TypeMapping{
-        .name = "AccountFilter",
-        .hidden_fields = &.{"reserved"},
-        .docs_link = "reference/account-filter#",
-    } },
-    .{ tb.QueryFilter, TypeMapping{
-        .name = "QueryFilter",
-        .hidden_fields = &.{"reserved"},
-        .docs_link = "reference/query-filter#",
-    } },
-    .{ tb.AccountBalance, TypeMapping{
-        .name = "AccountBalance",
-        .hidden_fields = &.{"reserved"},
-        .docs_link = "reference/account-balances#",
-    } },
-    .{ tb_client.Operation, TypeMapping{
-        .name = "Operation",
-        .hidden_fields = &.{ "reserved", "root", "register" },
-    } },
-};
-
-fn typescript_type(comptime Type: type) []const u8 {
-    switch (@typeInfo(Type)) {
-        .@"enum" => return comptime get_mapped_type_name(Type) orelse @compileError(
-            "Type " ++ @typeName(Type) ++ " not mapped.",
-        ),
-        .@"struct" => |info| switch (info.layout) {
-            .@"packed" => return comptime typescript_type(
-                std.meta.Int(.unsigned, @bitSizeOf(Type)),
-            ),
-            else => return comptime get_mapped_type_name(Type) orelse @compileError(
-                "Type " ++ @typeName(Type) ++ " not mapped.",
-            ),
-        },
-        .int => |info| {
-            assert(info.signedness == .unsigned);
-            return switch (info.bits) {
-                16 => "number",
-                32 => "number",
-                64 => "bigint",
-                128 => "bigint",
-                else => @compileError("invalid int type: " ++ @typeName(Type)),
-            };
-        },
-        else => @compileError("Unhandled type: " ++ @typeName(Type)),
-    }
-}
-
-fn get_mapped_type_name(comptime Type: type) ?[]const u8 {
-    inline for (type_mappings) |type_mapping| {
-        if (Type == type_mapping[0]) {
-            return type_mapping[1].name;
-        }
-    } else return null;
-}
-
-fn emit_enum(
-    buffer: *std.ArrayList(u8),
-    comptime Type: type,
-    comptime mapping: TypeMapping,
-) !void {
-    try emit_docs(buffer, mapping, 0, null);
-
-    try buffer.writer().print("export enum {s} {{\n", .{mapping.name});
-
-    inline for (@typeInfo(Type).@"enum".fields) |field| {
-        if (comptime std.mem.startsWith(u8, field.name, "deprecated_")) continue;
-        if (comptime mapping.hidden(field.name)) continue;
-
-        try emit_docs(buffer, mapping, 1, field.name);
-
-        try buffer.writer().print("  {s} = {d},\n", .{
-            field.name,
-            @intFromEnum(@field(Type, field.name)),
-        });
-    }
-
-    try buffer.writer().print("}}\n\n", .{});
-}
-
-fn emit_packed_struct(
-    buffer: *std.ArrayList(u8),
-    comptime type_info: anytype,
-    comptime mapping: TypeMapping,
-) !void {
-    assert(type_info.layout == .@"packed");
-    try emit_docs(buffer, mapping, 0, null);
-
-    try buffer.writer().print(
-        \\export enum {s} {{
-        \\  none = 0,
-        \\
-    , .{mapping.name});
-
-    inline for (type_info.fields, 0..) |field, i| {
-        if (comptime mapping.hidden(field.name)) continue;
-
-        try emit_docs(buffer, mapping, 1, field.name);
-
-        try buffer.writer().print("  {s} = (1 << {d}),\n", .{
-            field.name,
-            i,
-        });
-    }
-
-    try buffer.writer().print("}}\n\n", .{});
-}
-
-fn emit_struct(
-    buffer: *std.ArrayList(u8),
-    comptime type_info: anytype,
-    comptime mapping: TypeMapping,
-) !void {
-    try emit_docs(buffer, mapping, 0, null);
-
-    try buffer.writer().print("export type {s} = {{\n", .{
-        mapping.name,
-    });
-
-    inline for (type_info.fields) |field| {
-        if (comptime mapping.hidden(field.name)) continue;
-
-        try emit_docs(buffer, mapping, 1, field.name);
-
-        switch (@typeInfo(field.type)) {
-            .array => try buffer.writer().print("  {s}: Buffer\n", .{
-                field.name,
-            }),
-            else => try buffer.writer().print(
-                "  {s}: {s}\n",
-                .{
-                    field.name,
-                    typescript_type(field.type),
-                },
-            ),
-        }
-    }
-
-    try buffer.writer().print("}}\n\n", .{});
-}
-
-fn emit_docs(
-    buffer: anytype,
-    comptime mapping: TypeMapping,
-    comptime indent: comptime_int,
-    comptime field: ?[]const u8,
-) !void {
-    if (mapping.docs_link) |docs_link| {
-        try buffer.writer().print(
-            \\
-            \\{[indent]s}/**
-            \\{[indent]s}* See [{[name]s}](https://docs.tigerbeetle.com/{[docs_link]s}{[field]s})
-            \\{[indent]s}*/
-            \\
-        , .{
-            .indent = "  " ** indent,
-            .name = field orelse mapping.name,
-            .docs_link = docs_link,
-            .field = field orelse "",
-        });
-    }
-}
-
-pub fn generate_bindings(buffer: *std.ArrayList(u8)) !void {
-    @setEvalBranchQuota(100_000);
-
-    try buffer.writer().print(
-        \\///////////////////////////////////////////////////////
-        \\// This file was auto-generated by node_bindings.zig //
-        \\//              Do not manually modify.              //
-        \\///////////////////////////////////////////////////////
-        \\
-        \\
-    , .{});
-
-    // Emit JS declarations.
-    inline for (type_mappings) |type_mapping| {
-        const ZigType = type_mapping[0];
-        const mapping = type_mapping[1];
-
-        switch (@typeInfo(ZigType)) {
-            .@"struct" => |info| switch (info.layout) {
-                .auto => @compileError(
-                    "Only packed or extern structs are supported: " ++ @typeName(ZigType),
-                ),
-                .@"packed" => try emit_packed_struct(buffer, info, mapping),
-                .@"extern" => try emit_struct(buffer, info, mapping),
-            },
-            .@"enum" => try emit_enum(buffer, ZigType, mapping),
-            else => @compileError("Type cannot be represented: " ++ @typeName(ZigType)),
-        }
-    }
-}
-
-pub fn main() !void {
-    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    var buffer = std.ArrayList(u8).init(allocator);
-    try generate_bindings(&buffer);
-    try std.io.getStdOut().writeAll(buffer.items);
-}

data/ext/tb_client/tigerbeetle/src/clients/node/src/c.zig

@@ -1,3 +0,0 @@
-pub const c = @cImport({
-    @cInclude("node_api.h");
-});

data/ext/tb_client/tigerbeetle/src/clients/node/src/translate.zig

@@ -1,379 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const c = @import("c.zig").c;
-
-pub fn register_function(
-    env: c.napi_env,
-    exports: c.napi_value,
-    comptime name: [:0]const u8,
-    function: *const fn (env: c.napi_env, info: c.napi_callback_info) callconv(.c) c.napi_value,
-) !void {
-    var napi_function: c.napi_value = undefined;
-    if (c.napi_create_function(env, null, 0, function, null, &napi_function) != c.napi_ok) {
-        return throw(env, "Failed to create function " ++ name ++ "().");
-    }
-
-    if (c.napi_set_named_property(
-        env,
-        exports,
-        @as([*c]const u8, @ptrCast(name)),
-        napi_function,
-    ) != c.napi_ok) {
-        return throw(env, "Failed to add " ++ name ++ "() to exports.");
-    }
-}
-
-const TranslationError = error{ExceptionThrown};
-pub fn throw(env: c.napi_env, comptime message: [:0]const u8) TranslationError {
-    const result = c.napi_throw_error(env, null, @as([*c]const u8, @ptrCast(message)));
-    switch (result) {
-        c.napi_ok, c.napi_pending_exception => {},
-        else => unreachable,
-    }
-
-    return TranslationError.ExceptionThrown;
-}
-
-pub fn capture_null(env: c.napi_env) !c.napi_value {
-    var result: c.napi_value = undefined;
-    if (c.napi_get_null(env, &result) != c.napi_ok) {
-        return throw(env, "Failed to capture the value of \"null\".");
-    }
-
-    return result;
-}
-
-pub fn extract_args(env: c.napi_env, info: c.napi_callback_info, comptime args: struct {
-    count: usize,
-    function: []const u8,
-}) ![args.count]c.napi_value {
-    var argc = args.count;
-    var argv: [args.count]c.napi_value = undefined;
-    if (c.napi_get_cb_info(env, info, &argc, &argv, null, null) != c.napi_ok) {
-        return throw(
-            env,
-            std.fmt.comptimePrint("Failed to get args for {s}()\x00", .{args.function}),
-        );
-    }
-
-    if (argc != args.count) {
-        return throw(
-            env,
-            std.fmt.comptimePrint("Function {s}() requires exactly {} arguments.\x00", .{
-                args.function,
-                args.count,
-            }),
-        );
-    }
-
-    return argv;
-}
-
-pub fn create_external(env: c.napi_env, context: *anyopaque) !c.napi_value {
-    var result: c.napi_value = null;
-    if (c.napi_create_external(env, context, null, null, &result) != c.napi_ok) {
-        return throw(env, "Failed to create external for client context.");
-    }
-
-    return result;
-}
-
-pub fn value_external(
-    env: c.napi_env,
-    value: c.napi_value,
-    comptime error_message: [:0]const u8,
-) !?*anyopaque {
-    var result: ?*anyopaque = undefined;
-    if (c.napi_get_value_external(env, value, &result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    return result;
-}
-
-pub fn slice_from_object(
-    env: c.napi_env,
-    object: c.napi_value,
-    comptime key: [:0]const u8,
-) ![]const u8 {
-    var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
-        return throw(env, key ++ " must be defined");
-    }
-
-    return slice_from_value(env, property, key);
-}
-
-pub fn slice_from_value(
-    env: c.napi_env,
-    value: c.napi_value,
-    comptime key: [:0]const u8,
-) ![]u8 {
-    var is_buffer: bool = undefined;
-    assert(c.napi_is_buffer(env, value, &is_buffer) == c.napi_ok);
-
-    if (!is_buffer) return throw(env, key ++ " must be a buffer");
-
-    var data: ?*anyopaque = null;
-    var data_length: usize = undefined;
-    assert(c.napi_get_buffer_info(env, value, &data, &data_length) == c.napi_ok);
-
-    if (data_length < 1) return throw(env, key ++ " must not be empty");
-
-    return @as([*]u8, @ptrCast(data.?))[0..data_length];
-}
-
-pub fn u128_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u128 {
-    var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
-        return throw(env, key ++ " must be defined");
-    }
-
-    return u128_from_value(env, property, key);
-}
-
-pub fn u64_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u64 {
-    var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
-        return throw(env, key ++ " must be defined");
-    }
-
-    return u64_from_value(env, property, key);
-}
-
-pub fn u32_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u32 {
-    var property: c.napi_value = undefined;
-    if (c.napi_get_named_property(env, object, key, &property) != c.napi_ok) {
-        return throw(env, key ++ " must be defined");
-    }
-
-    return u32_from_value(env, property, key);
-}
-
-pub fn u16_from_object(env: c.napi_env, object: c.napi_value, comptime key: [:0]const u8) !u16 {
-    const result = try u32_from_object(env, object, key);
-    if (result > std.math.maxInt(u16)) {
-        return throw(env, key ++ " must be a u16.");
-    }
-
-    return @as(u16, @intCast(result));
-}
-
-pub fn u128_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]const u8) !u128 {
-    // A BigInt's value (using ^ to mean exponent) is
-    // (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...).
-
-    // V8 says that the words are little endian. If we were on a big endian machine
-    // we would need to convert, but big endian is not supported by tigerbeetle.
-    var result: u128 = 0;
-    var sign_bit: c_int = undefined;
-    const words: *[2]u64 = @ptrCast(&result);
-    var word_count: usize = 2;
-    switch (c.napi_get_value_bigint_words(env, value, &sign_bit, &word_count, words)) {
-        c.napi_ok => {},
-        c.napi_bigint_expected => return throw(env, name ++ " must be a BigInt"),
-        else => unreachable,
-    }
-    if (sign_bit != 0) return throw(env, name ++ " must be positive");
-    if (word_count > 2) return throw(env, name ++ " must fit in 128 bits");
-
-    return result;
-}
-
-pub fn u64_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]const u8) !u64 {
-    var result: u64 = undefined;
-    var lossless: bool = undefined;
-    switch (c.napi_get_value_bigint_uint64(env, value, &result, &lossless)) {
-        c.napi_ok => {},
-        c.napi_bigint_expected => return throw(env, name ++ " must be an unsigned 64-bit BigInt"),
-        else => unreachable,
-    }
-    if (!lossless) return throw(env, name ++ " conversion was lossy");
-
-    return result;
-}
-
-pub fn u32_from_value(env: c.napi_env, value: c.napi_value, comptime name: [:0]const u8) !u32 {
-    var result: u32 = undefined;
-    // TODO Check whether this will coerce signed numbers to a u32:
-    // In that case we need to use the appropriate napi method to do more type checking here.
-    // We want to make sure this is: unsigned, and an integer.
-    switch (c.napi_get_value_uint32(env, value, &result)) {
-        c.napi_ok => {},
-        c.napi_number_expected => return throw(env, name ++ " must be a number"),
-        else => unreachable,
-    }
-    return result;
-}
-
-pub fn u128_into_object(
-    env: c.napi_env,
-    object: c.napi_value,
-    comptime key: [:0]const u8,
-    value: u128,
-    comptime error_message: [:0]const u8,
-) !void {
-    // A BigInt's value (using ^ to mean exponent) is
-    // (words[0] * (2^64)^0 + words[1] * (2^64)^1 + ...).
-
-    // V8 says that the words are little endian. If we were on a big endian machine
-    // we would need to convert, but big endian is not supported by tigerbeetle.
-    var bigint: c.napi_value = undefined;
-    if (c.napi_create_bigint_words(
-        env,
-        0,
-        2,
-        @as(*const [2]u64, @ptrCast(&value)),
-        &bigint,
-    ) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    if (c.napi_set_named_property(
-        env,
-        object,
-        @ptrCast(key),
-        bigint,
-    ) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-}
-
-pub fn u64_into_object(
-    env: c.napi_env,
-    object: c.napi_value,
-    comptime key: [:0]const u8,
-    value: u64,
-    comptime error_message: [:0]const u8,
-) !void {
-    var result: c.napi_value = undefined;
-    if (c.napi_create_bigint_uint64(env, value, &result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    if (c.napi_set_named_property(
-        env,
-        object,
-        @ptrCast(key),
-        result,
-    ) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-}
-
-pub fn u32_into_object(
-    env: c.napi_env,
-    object: c.napi_value,
-    comptime key: [:0]const u8,
-    value: u32,
-    comptime error_message: [:0]const u8,
-) !void {
-    var result: c.napi_value = undefined;
-    if (c.napi_create_uint32(env, value, &result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    if (c.napi_set_named_property(env, object, @ptrCast(key), result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-}
-
-pub fn u16_into_object(
-    env: c.napi_env,
-    object: c.napi_value,
-    comptime key: [:0]const u8,
-    value: u16,
-    comptime error_message: [:0]const u8,
-) !void {
-    try u32_into_object(env, object, key, value, error_message);
-}
-
-pub fn create_object(env: c.napi_env, comptime error_message: [:0]const u8) !c.napi_value {
-    var result: c.napi_value = undefined;
-    if (c.napi_create_object(env, &result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    return result;
-}
-
-pub fn create_array(
-    env: c.napi_env,
-    length: u32,
-    comptime error_message: [:0]const u8,
-) !c.napi_value {
-    var result: c.napi_value = undefined;
-    if (c.napi_create_array_with_length(env, length, &result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    return result;
-}
-
-pub fn set_array_element(
-    env: c.napi_env,
-    array: c.napi_value,
-    index: u32,
-    value: c.napi_value,
-    comptime error_message: [:0]const u8,
-) !void {
-    if (c.napi_set_element(env, array, index, value) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-}
-
-pub fn array_element(env: c.napi_env, array: c.napi_value, index: u32) !c.napi_value {
-    var element: c.napi_value = undefined;
-    if (c.napi_get_element(env, array, index, &element) != c.napi_ok) {
-        return throw(env, "Failed to get array element.");
-    }
-
-    return element;
-}
-
-pub fn array_length(env: c.napi_env, array: c.napi_value) !u32 {
-    var is_array: bool = undefined;
-    assert(c.napi_is_array(env, array, &is_array) == c.napi_ok);
-    if (!is_array) return throw(env, "Batch must be an Array.");
-
-    var length: u32 = undefined;
-    assert(c.napi_get_array_length(env, array, &length) == c.napi_ok);
-
-    return length;
-}
-
-pub fn delete_reference(env: c.napi_env, reference: c.napi_ref) !void {
-    if (c.napi_delete_reference(env, reference) != c.napi_ok) {
-        return throw(env, "Failed to delete callback reference.");
-    }
-}
-
-pub fn call_function(
-    env: c.napi_env,
-    this: c.napi_value,
-    callback: c.napi_value,
-    args: []c.napi_value,
-) !c.napi_value {
-    var result: c.napi_value = undefined;
-    switch (c.napi_call_function(env, this, callback, args.len, args.ptr, &result)) {
-        c.napi_ok => {},
-        // the user's callback may throw a JS exception or call other functions that do so. We
-        // therefore don't throw another error.
-        c.napi_pending_exception => {},
-        else => return throw(env, "Failed to invoke results callback."),
-    }
-    return result;
-}
-
-pub fn reference_value(
-    env: c.napi_env,
-    callback_reference: c.napi_ref,
-    comptime error_message: [:0]const u8,
-) !c.napi_value {
-    var result: c.napi_value = undefined;
-    if (c.napi_get_reference_value(env, callback_reference, &result) != c.napi_ok) {
-        return throw(env, error_message);
-    }
-
-    return result;
-}