TableMethods

TableMethods are accessed directly by table: jsorm.users, jsorm.cache.sessions. There is no jsorm.from(Model).

All methods are async and return { data: T }.

---

.first()

first(options?: { select?; where? }): Promise<ProviderResult<Record | null>>

Returns the first result or null.

// Without select → returns full model
const { data: user } = await jsorm.users.first({
  where: { email: "test@test.com" },
});

// With select → returns only selected fields
const { data: user } = await jsorm.users.first({
  select: { name: true, role: { name: true } },
  where: { email: "test@test.com" },
});

---

.get()

get(options?: { select?; where?; orderBy?; groupBy?; pagination?; limit?; offset? }): Promise<ProviderResult<Record[]> & { meta?: ... }>

// Without select
const { data: users } = await jsorm.users.get({ where: { active: true } });

// With select
const { data: users } = await jsorm.users.get({
  select: { id: true, name: true, role: { name: true } },
  where: { active: true },
  orderBy: { createdAt: "desc" },
});

// With pagination
const { data: users, meta } = await jsorm.users.get({
  select: { id: true, name: true },
  pagination: { page: 1, perPage: 10 },
});

---

.cursor()

cursor(options: CursorOptions): Promise<CursorResult<Record>>

Cursor-based pagination. orderBy is required.

const { data: users, meta } = await jsorm.users.cursor({
  select: { id: true, name: true },
  orderBy: { id: "asc" },
  limit: 20,
});
// meta.cursor.next — cursor for next page
// meta.cursor.hasNext — true if there are more records

---

.count()

count(options?: { where? }): Promise<ProviderResult<number>>

const { data: total } = await jsorm.users.count({ where: { active: true } });

---

.exists()

exists(options?: { where? }): Promise<ProviderResult<boolean>>

const { data: hasAdmin } = await jsorm.users.exists({ where: { role: { name: "admin" } } });

---

.create()

create(data: CreateInput): Promise<ProviderResult<Record>>

Fields with .autoCreate() are excluded from the input.

const { data: user } = await jsorm.users.create({
  name: "Juan",
  email: "juan@test.com",
});

---

.createMany()

createMany(data: CreateInput[], options?: { maxRows?: number }): Promise<ProviderResult<Record[]>>

Creates multiple records in one call. maxRows caps the batch.

const { data: users } = await jsorm.users.createMany([
  { name: "Ana", email: "ana@test.com" },
  { name: "Luis", email: "luis@test.com" },
]);

---

.update()

update(options: { where?; data }): Promise<ProviderResult<number>>

Returns number of affected rows.

const { data: updated } = await jsorm.users.update({
  where: { email: "juan@test.com" },
  data: { name: "Juan Carlos" },
});

---

.updateMany()

updateMany(data: UpdateInput[], options?: { maxRows?: number }): Promise<ProviderResult<number>>

Each row is matched by primary key only — there is no where option. Include the primary key field (id, or the field marked .primary()) in every row; rows without it are skipped.

const { data: updated } = await jsorm.users.updateMany([
  { id: "1", name: "Ana María" },
  { id: "2", name: "Luis Alberto" },
]);

---

.delete()

delete(options?: { where? }): Promise<ProviderResult<number>>

Returns number of deleted rows. A where is required for updates/deletes.

const { data: deleted } = await jsorm.users.delete({
  where: { id: "abc-123" },
});

---

.deleteMany()

deleteMany(options?: { where? }): Promise<ProviderResult<number>>

const { data: deleted } = await jsorm.users.deleteMany({
  where: { active: false },
});

---

.attach()

attach(parentId: string | number, relation: string, data: JunctionData): Promise<ProviderResult<number>>

// Attach a role to a user through the users_roles junction
const { data: attached } = await jsorm.users.attach(userId, "roles", {
  roleId: "role-admin",
});

---

.detach()

detach(parentId: string | number, relation: string, data?: JunctionData): Promise<ProviderResult<number>>

// Detach a role from a user
const { data: detached } = await jsorm.users.detach(userId, "roles", {
  roleId: "role-admin",
});