Add build flags for sqlite/postgres support

build.zig

@@ -1,40 +1,66 @@
 const std = @import("std");
+const Pkg = std.build.Pkg;
 
-const util_pkg = std.build.Pkg{
+const Packages = struct {
-    .name = "util",
+    opts: Pkg,
-    .source = std.build.FileSource.relative("src/util/lib.zig"),
+    util: Pkg,
+    http: Pkg,
+    sql: Pkg,
+    api: Pkg,
+    template: Pkg,
+    main: Pkg,
 };
 
-const http_pkg = std.build.Pkg{
+fn makePkgs(b: *std.build.Builder, build_options: Pkg) Packages {
-    .name = "http",
+    const opt = b.dupePkg(build_options);
-    .source = std.build.FileSource.relative("src/http/lib.zig"),
+    const util_pkg = b.dupePkg(.{
-    .dependencies = &.{util_pkg},
+        .name = "util",
-};
+        .source = std.build.FileSource.relative("src/util/lib.zig"),
+        .dependencies = &.{opt},
+    });
 
-const sql_pkg = std.build.Pkg{
+    const http_pkg = b.dupePkg(.{
-    .name = "sql",
+        .name = "http",
-    .source = std.build.FileSource.relative("src/sql/lib.zig"),
+        .source = std.build.FileSource.relative("src/http/lib.zig"),
-    .dependencies = &.{util_pkg},
+        .dependencies = &.{ util_pkg, opt },
-};
+    });
 
-const api_pkg = std.build.Pkg{
+    const sql_pkg = b.dupePkg(.{
-    .name = "api",
+        .name = "sql",
-    .source = std.build.FileSource.relative("src/api/lib.zig"),
+        .source = std.build.FileSource.relative("src/sql/lib.zig"),
-    .dependencies = &.{ util_pkg, sql_pkg },
+        .dependencies = &.{ util_pkg, opt },
-};
+    });
 
-const template_pkg = std.build.Pkg{
+    const api_pkg = b.dupePkg(.{
-    .name = "template",
+        .name = "api",
-    .source = std.build.FileSource.relative("src/template/lib.zig"),
+        .source = std.build.FileSource.relative("src/api/lib.zig"),
-};
+        .dependencies = &.{ util_pkg, sql_pkg, opt },
+    });
 
-const main_pkg = std.build.Pkg{
+    const template_pkg = b.dupePkg(.{
-    .name = "main",
+        .name = "template",
-    .source = std.build.FileSource.relative("src/main/main.zig"),
+        .source = std.build.FileSource.relative("src/template/lib.zig"),
-    .dependencies = &.{ util_pkg, http_pkg, sql_pkg, api_pkg, template_pkg },
+        .dependencies = &.{opt},
-};
+    });
 
-pub fn build(b: *std.build.Builder) void {
+    const main_pkg = b.dupePkg(.{
+        .name = "main",
+        .source = std.build.FileSource.relative("src/main/main.zig"),
+        .dependencies = &.{ util_pkg, http_pkg, sql_pkg, api_pkg, template_pkg, opt },
+    });
+
+    return Packages{
+        .opts = opt,
+        .util = util_pkg,
+        .http = http_pkg,
+        .sql = sql_pkg,
+        .api = api_pkg,
+        .template = template_pkg,
+        .main = main_pkg,
+    };
+}
+
+pub fn build(b: *std.build.Builder) !void {
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
     // means any target is allowed, and the default is native. Other options
@@ -44,26 +70,38 @@ pub fn build(b: *std.build.Builder) void {
     // Standard release options allow the person running `zig build` to select
     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
     const mode = b.standardReleaseOptions();
+    const options = b.addOptions();
+    const enable_sqlite = b.option(bool, "sqlite", "Enable the use of sqlite as a database engine") orelse true;
+    const enable_postgres = b.option(bool, "postgres", "Enable the use of postgres as a database engine") orelse true;
+    options.addOption(bool, "enable_sqlite", enable_sqlite);
+    options.addOption(bool, "enable_postgres", enable_postgres);
+    if (!enable_sqlite and !enable_postgres) {
+        std.log.err("No database engine enabled", .{});
+        return error.InvalidBuildOptions;
+    }
+
+    const pkgs = makePkgs(b, options.getPackage("build_options"));
 
     const exe = b.addExecutable("apub", "src/main/main.zig");
     exe.setTarget(target);
     exe.setBuildMode(mode);
 
-    exe.addPackage(sql_pkg);
+    exe.addPackage(pkgs.opts);
-    exe.addPackage(util_pkg);
+    exe.addPackage(pkgs.sql);
-    exe.addPackage(http_pkg);
+    exe.addPackage(pkgs.util);
-    exe.addPackage(api_pkg);
+    exe.addPackage(pkgs.http);
-    exe.addPackage(template_pkg);
+    exe.addPackage(pkgs.api);
+    exe.addPackage(pkgs.template);
 
-    exe.linkSystemLibrary("sqlite3");
+    if (enable_sqlite) exe.linkSystemLibrary("sqlite3");
-    exe.linkSystemLibrary("pq");
+    if (enable_postgres) exe.linkSystemLibrary("pq");
     exe.linkLibC();
 
     //const util_tests = b.addTest("src/util/lib.zig");
     const http_tests = b.addTest("src/http/test.zig");
     //const sql_tests = b.addTest("src/sql/lib.zig");
-    http_tests.addPackage(util_pkg);
+    http_tests.addPackage(pkgs.util);
-    //sql_tests.addPackage(util_pkg);
+    //sql_tests.addPackage(pkgs.util);
 
     const unit_tests = b.step("unit-tests", "Run tests");
     //unit_tests.dependOn(&util_tests.step);
@@ -71,14 +109,15 @@ pub fn build(b: *std.build.Builder) void {
     //unit_tests.dependOn(&sql_tests.step);
 
     const api_integration = b.addTest("./tests/api_integration/lib.zig");
-    api_integration.addPackage(sql_pkg);
+    api_integration.addPackage(pkgs.opts);
-    api_integration.addPackage(util_pkg);
+    api_integration.addPackage(pkgs.sql);
-    api_integration.addPackage(http_pkg);
+    api_integration.addPackage(pkgs.util);
-    api_integration.addPackage(main_pkg);
+    api_integration.addPackage(pkgs.http);
-    api_integration.addPackage(api_pkg);
+    api_integration.addPackage(pkgs.main);
+    api_integration.addPackage(pkgs.api);
     api_integration.linkLibC();
-    api_integration.linkSystemLibrary("sqlite3");
+    if (enable_sqlite) api_integration.linkSystemLibrary("sqlite3");
-    api_integration.linkSystemLibrary("pq");
+    if (enable_postgres) api_integration.linkSystemLibrary("pq");
 
     const integration_tests = b.step("integration-tests", "run tests");
     integration_tests.dependOn(&api_integration.step);

src/sql/lib.zig

@@ -1,10 +1,16 @@
 const std = @import("std");
 const util = @import("util");
+const build_options = @import("build_options");
 
-const postgres = @import("./engines/postgres.zig");
+const postgres = if (build_options.enable_postgres)
-//const postgres = @import("./engines/null.zig");
+    @import("./engines/postgres.zig")
-const sqlite = @import("./engines/sqlite.zig");
+else
-//const sqlite = @import("./engines/null.zig");
+    @import("./engines/null.zig");
+
+const sqlite = if (build_options.enable_sqlite)
+    @import("./engines/sqlite.zig")
+else
+    @import("./engines/null.zig");
 const common = @import("./engines/common.zig");
 const Allocator = std.mem.Allocator;