Using Naite

import { Naite } from "sonamu";

describe("User API", () => {
  test("create user", async () => {
    const email = "test@example.com";

    // Record log
    Naite.t("user.create.input", { email });

    const user = await UserModel.create({ email });

    Naite.t("user.create.output", { userId: user.id });

    expect(user.email).toBe(email);
  });
});

test("debugging example", async () => {
  try {
    const result = await complexOperation();
    expect(result).toBe(expectedValue);
  } catch (error) {
    // Check logs on failure
    const logs = Naite.getAll();
    console.log("Test logs:", logs);
    throw error;
  }
});

test("API call tracking", async () => {
  const params = { page: 1, limit: 10 };

  // Record request
  Naite.t("api.request", {
    method: "findMany",
    params
  });

  const users = await UserModel.findMany(params);

  // Record response
  Naite.t("api.response", {
    count: users.length,
    firstUser: users[0]
  });

  expect(users.length).toBeGreaterThan(0);
});

test("query tracking", async () => {
  const userId = 1;

  // Before query
  Naite.t("db.query.before", { userId });

  const user = await UserModel.findById(userId);

  // After query
  Naite.t("db.query.after", {
    found: !!user,
    data: user
  });

  expect(user).toBeDefined();
});

test("order process tracking", async () => {
  const orderId = 1;

  Naite.t("order.process.start", { orderId });

  // 1. Get order
  const order = await OrderModel.findById(orderId);
  Naite.t("order.found", { status: order.status });

  // 2. Process payment
  const payment = await processPayment(order);
  Naite.t("payment.processed", {
    paymentId: payment.id,
    amount: payment.amount
  });

  // 3. Update order status
  await OrderModel.updateStatus(orderId, "paid");
  Naite.t("order.status.updated", { newStatus: "paid" });

  Naite.t("order.process.complete", { orderId });
});

// Good key naming
Naite.t("user.create.input", data);
Naite.t("user.create.validation", result);
Naite.t("user.create.output", user);

// Domain separation
Naite.t("order.payment.start", params);
Naite.t("order.payment.complete", result);

// Bad key naming
Naite.t("data1", data);
Naite.t("result", result);
Naite.t("test", value);

{domain}.{action}.{stage}
Example: user.create.input, order.payment.complete

const DEBUG = process.env.DEBUG === "true";

test("conditional logging", async () => {
  if (DEBUG) {
    Naite.t("debug.start", { timestamp: Date.now() });
  }

  const result = await someOperation();

  if (DEBUG) {
    Naite.t("debug.result", result);
  }

  expect(result).toBeDefined();
});

class UserModelClass extends BaseModel {
  @api()
  async createUser(name: string, email: string) {
    // Record log with Naite.t()
    Naite.t("user.input", { name, email });

    const user = await this.save({ name, email });

    Naite.t("user.created", user);

    return user;
  }
}

test("verify Naite logs", async () => {
  await UserModel.createUser("Alice", "alice@example.com");

  // Extract first data with .first()
  const input = Naite.get("user.input").first();
  const created = Naite.get("user.created").first();

  expect(input.name).toBe("Alice");
  expect(created.id).toBeDefined();
});

test("log queries", async () => {
  // Perform multiple operations
  await createUsers();
  await processOrders();

  // Query by specific key
  const userLogs = Naite.get("user").result();

  // Query by pattern (wildcard supported)
  const createLogs = Naite.get("*.create.*").result();

  // All logs
  const allLogs = Naite.getAll();

  console.log("User logs:", userLogs);
  console.log("Create logs:", createLogs);
  console.log("All logs:", allLogs);
});

test("NaiteQuery methods", async () => {
  Naite.t("test.data", { value: 1 });
  Naite.t("test.data", { value: 2 });
  Naite.t("test.data", { value: 3 });

  // First data
  const first = Naite.get("test.data").first();
  console.log(first); // { value: 1 }

  // Last data
  const last = Naite.get("test.data").last();
  console.log(last); // { value: 3 }

  // All data as array
  const all = Naite.get("test.data").result();
  console.log(all); // [{ value: 1 }, { value: 2 }, { value: 3 }]
});

# Run tests
pnpm test

# Run Naite Viewer
pnpm naite:view

test("failing test", async () => {
  // Add sufficient logs
  Naite.t("test.start", { timestamp: Date.now() });

  try {
    const result = await problematicFunction();
    Naite.t("test.result", result);
    expect(result).toBe(expectedValue);
  } catch (error) {
    // Output all logs on error
    console.log("=== Naite Logs ===");
    console.log(JSON.stringify(Naite.getAll(), null, 2));
    throw error;
  }
});

afterEach(() => {
  // Summarize logs after test
  const allLogs = Naite.getAll();
  const errorKeys = Object.keys(allLogs).filter(key =>
    key.includes("error") || key.includes("fail")
  );

  if (errorKeys.length > 0) {
    const errorLogs = errorKeys.map(key => ({ key, data: allLogs[key] }));
    console.log("Warning - Error logs:", errorLogs);
  }
});

test("bug reproduction", async () => {
  // Reproduce the scenario where the bug occurred
  Naite.t("bug.reproduction.start", {
    scenario: "Delete user immediately after creation"
  });

  const user = await UserModel.create({ email: "test@example.com" });
  Naite.t("bug.user.created", user);

  await UserModel.del(user.id);
  Naite.t("bug.user.deleted", { userId: user.id });

  // Attempt to retrieve again
  const deletedUser = await UserModel.findById(user.id);
  Naite.t("bug.user.found", { found: !!deletedUser });

  expect(deletedUser).toBeNull();
});

test("performance measurement", async () => {
  const start = Date.now();
  Naite.t("perf.start", { timestamp: start });

  // Heavy operation
  const result = await heavyOperation();

  const end = Date.now();
  Naite.t("perf.end", {
    timestamp: end,
    duration: end - start,
    result
  });

  // Verify performance criteria
  expect(end - start).toBeLessThan(1000); // Within 1 second
});

// Do not use Naite in production code
class UserModelClass extends BaseModel {
  async createUser() {
    Naite.t("user.create", data); // Bad - Test only!
    return this.save(data);
  }
}

test("logging cautions", async () => {
  // Do not log sensitive information like passwords
  Naite.t("user.create", {
    email,
    password  // Bad
  });

  // Exclude sensitive information
  Naite.t("user.create", {
    email,
    hasPassword: !!password  // Good
  });
});

// Excessive logging inside loops
for (let i = 0; i < 1000; i++) {
  Naite.t(`item.${i}`, data); // Bad - Too many
}

// Summary logging
Naite.t("items.processed", {
  count: 1000,
  sample: items.slice(0, 3)  // Good - Sample only
});