.dependencies = .{
    .fluentorm = .{
        .url = "git+https://github.com/SOG-web/fluentorm.zig#main",
        .hash = "<hash>",
    },
},

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // Migration directory option - users can override this
    const migrations_dir = b.option([]const u8, "migrations-dir", "Directory containing migration files") orelse "migrations";

    // Skip migrations option
    const skip_migrations = b.option(bool, "skip-migrations", "Skip generating SQL migrations") orelse false;

    // Get the fluentorm dependency
    const fluentorm_dep = b.dependency("fluentorm", .{
        .target = target,
        .optimize = optimize,
    });
    const fluentorm = fluentorm_dep.module("fluentorm");

    // Your main executable
    const exe = b.addExecutable(.{
        .name = "my-app",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "fluentorm", .module = fluentorm },
            },
        }),
    });
    b.installArtifact(exe);

    // Step 1: Generate registry and runner from schemas
    const gen_step = b.step("generate", "Generate registry and runner from schemas");
    const gen_exe = fluentorm_dep.artifact("fluentzig-gen");
    const gen_cmd = b.addRunArtifact(gen_exe);
    gen_cmd.addArgs(&.{ "schemas", "src/models/generated" });
    if (!skip_migrations) {
        gen_cmd.addArg(migrations_dir);
    } else {
        gen_cmd.addArg("--skip-migrations");
    }
    gen_step.dependOn(&gen_cmd.step);

    // Step 2: Run the generated runner to create model files
    const runner_exe = b.addExecutable(.{
        .name = "model-runner",
        .root_module = b.createModule(.{
            .root_source_file = b.path("schemas/runner.zig"),
            .target = target,
            .optimize = optimize,
            .imports = &.{
                .{ .name = "fluentorm", .module = fluentorm },
            },
        }),
    });
    const gen_models_step = b.step("generate-models", "Generate model files from schemas");
    gen_models_step.dependOn(&b.addRunArtifact(runner_exe).step);
}

const fluentorm = @import("fluentorm");
const TableSchema = fluentorm.TableSchema;

pub fn build(t: *TableSchema) void {
    // Primary key - UUID auto-generated
    t.uuid(.{
        .name = "id",
        .primary_key = true,
        .unique = true,
        .create_input = .excluded,
        .update_input = false,
    });

    // User fields
    t.string(.{ .name = "email", .unique = true });
    t.string(.{ .name = "name" });
    t.string(.{ .name = "password_hash", .redacted = true });

    // Timestamps (adds created_at and updated_at)
    t.timestamps();

    // Soft delete support (adds deleted_at)
    t.softDelete();
}

const fluentorm = @import("fluentorm");
const TableSchema = fluentorm.TableSchema;

pub fn build(t: *TableSchema) void {
    t.uuid(.{
        .name = "id",
        .primary_key = true,
        .unique = true,
        .create_input = .excluded,
        .update_input = false,
    });

    t.string(.{ .name = "title" });
    t.string(.{ .name = "content" });
    t.uuid(.{ .name = "user_id" }); // Foreign key

    t.dateTime(.{
        .name = "created_at",
        .create_input = .excluded,
        .update_input = false,
        .default_value = "CURRENT_TIMESTAMP",
        .auto_generated = true,
    });

    // Define relationship using convenience method
    t.belongsTo(.{
        .name = "post_author",
        .column = "user_id",
        .references_table = "users",
        .on_delete = .cascade,
    });
}

const std = @import("std");
const pg = @import("pg");
const models = @import("models/generated/root.zig");

const Executor = models.Executor;
const Users = models.Users;
const Posts = models.Posts;

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // Setup database connection
    var pool = try pg.Pool.init(allocator, .{
        .size = 5,
        .connect = .{
            .host = "localhost",
            .port = 5432,
        },
        .auth = .{
            .username = "postgres",
            .password = "password",
            .database = "mydb",
        },
    });
    defer pool.deinit();

    // Create an executor for pool access
    const db = Executor.fromPool(&pool);

    // Create a user (using unwrap() for simple error propagation)
    const user_id = try Users.insert(db, allocator, .{
        .email = "alice@example.com",
        .name = "Alice",
        .password_hash = "hashed_password",
    }).unwrap();
    defer allocator.free(user_id);

    // Query users
    var query = Users.query();
    defer query.deinit();

    const users = try query
        .where(.{ .field = .email, .operator = .eq, .value = .{ .string = "$1" } })
        .fetch(db, allocator, .{"alice@example.com"})
        .unwrap();
    defer allocator.free(users);

    // Get user with hasMany relationship
    const find_result = Users.findById(db, allocator, user_id);
    switch (find_result) {
        .ok => |maybe_user| {
            if (maybe_user) |user| {
                defer allocator.free(user);

                // Fetch related posts using hasMany
                const posts = try user.fetchPosts(&pool, allocator);
                defer allocator.free(posts);
            }
        },
        .err => |e| e.log(),
    }
}

.{
    .name = "field_name",              // Required: field name
    .primary_key = false,              // Is this a primary key?
    .unique = false,                   // Add unique constraint?
     .nullable = false,e,                  // Field is NOT NULL?
    .create_input = .required,         // .required, .optional, or .excluded
    .update_input = true,              // Include in UpdateInput?
    .redacted = false,                 // Exclude from JSON responses?
    .default_value = null,             // SQL default value
    .auto_generated = false,           // Auto-generated by database?
}

// Post belongs to User
t.belongsTo(.{
    .name = "post_author",
    .column = "user_id",
    .references_table = "users",
    .on_delete = .cascade,
});

// User has many Posts
t.hasMany(.{
    .name = "user_posts",
    .foreign_table = "posts",
    .foreign_column = "user_id",
});