init

src/main.zig

@@ -0,0 +1,121 @@
+//!
+//! Part of the Zap examples.
+//!
+//! Build me with `zig build     app_basic`.
+//! Run   me with `zig build run-app_basic`.
+//!
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const builtin = @import("builtin");
+const optimize_mode = builtin.mode;
+
+const zap = @import("zap");
+const sqlite = @import("sqlite");
+
+// The global Application Context
+const Context = @import("Context");
+
+// A very simple endpoint handling only GET requests
+const SimpleEndpoint = struct {
+
+    // zap.App.Endpoint Interface part
+    path: []const u8,
+    error_strategy: zap.Endpoint.ErrorStrategy = .log_to_response,
+
+    // data specific for this endpoint
+    component: []const u8,
+
+    pub fn init(path: []const u8, data: []const u8) SimpleEndpoint {
+        return .{
+            .path = path,
+            .component = data,
+        };
+    }
+
+    // handle GET requests
+    pub fn get(e: *SimpleEndpoint, arena: Allocator, context: *Context, r: zap.Request) !void {
+        const thread_id = std.Thread.getCurrentId();
+
+        try Context.SendInertiaResponse(e, r, arena, e.component, .{
+            .thread_id = thread_id,
+            .counter = context.counter,
+        });
+        context.*.counter += 1;
+    }
+};
+
+const StopEndpoint = struct {
+    path: []const u8,
+    error_strategy: zap.Endpoint.ErrorStrategy = .log_to_response,
+
+    pub fn get(_: *StopEndpoint, _: Allocator, context: *Context, _: zap.Request) !void {
+        std.debug.print(
+            \\Before I stop, let me dump the app context:
+            \\db_connection='{}'
+            \\
+            \\
+        , .{context.*.db_connection});
+        zap.stop();
+    }
+};
+
+pub fn main() !void {
+    // setup allocations
+    var gpa: std.heap.GeneralPurposeAllocator(.{
+        // just to be explicit
+        .thread_safe = true,
+    }) = .{};
+    defer std.debug.print("\n\nLeaks detected: {}\n\n", .{gpa.deinit() != .ok});
+    const allocator = gpa.allocator();
+
+    var db = try sqlite.Db.init(.{
+        .mode = sqlite.Db.Mode{ .File = "./storage/mydata.db" },
+        .open_flags = .{
+            .write = true,
+            .create = true,
+        },
+        .threading_mode = .MultiThread,
+    });
+    defer db.deinit();
+
+    // create an app context
+    var my_context = Context.init(db);
+
+    // create an App instance
+    // const App = zap.App.Create(Context);
+    const App = @import("./App.zig").Create(Context);
+    try App.init(allocator, &my_context, .{});
+    defer App.deinit();
+
+    // create the endpoints
+    var home_endpoint = SimpleEndpoint.init("/", "home/home");
+    var test_endpoint = SimpleEndpoint.init("/test", "home/test");
+    var stop_endpoint: StopEndpoint = .{ .path = "/stop" };
+
+    // register the endpoints with the App
+    try App.register(&stop_endpoint);
+    try App.register(&home_endpoint);
+    try App.register(&test_endpoint);
+
+    // listen on the network
+    try App.listen(.{
+        .interface = "0.0.0.0",
+        .port = 3000,
+        .public_folder = "./public",
+    });
+    std.debug.print("Listening on 0.0.0.0:3000\n", .{});
+
+    std.debug.print(
+        \\ Try me via:
+        \\ curl http://localhost:3000/test
+        \\ Stop me via:
+        \\ curl http://localhost:3000/stop
+        \\
+    , .{});
+
+    // start worker threads -- only 1 process!!!
+    zap.start(.{
+        .threads = 2,
+        .workers = 1,
+    });
+}