TenancyCopy page

import { connect } from "okmodel/pg/postgresjs";
import { schema, table, t } from "okmodel/pg";
import { columnTenancy, global } from "okmodel/tenancy";

const notes = table("notes", { id: t.identity(), title: t.text() });
const plans = table(
  "plans",
  { id: t.identity(), code: t.text() },
  { tenancy: global("plans are shared") },
);

export const app = schema({
  tables: [notes, plans],
  tenancy: columnTenancy({ key: "tenantId", type: "uuid" }),
});

const acme = "018f3b2c-7a11-7c3a-8e2d-6b4a9c1d0e5f";
const globex = "018f3b2c-7a11-7c3a-8e2d-6b4a9c1d0e60";

export async function isolate(url: string): Promise<void> {
  await using db = connect(url, { schema: app });
  const scoped = db.for({ tenantId: acme });

  console.log("insert:", JSON.stringify(await scoped.notes.insert({ title: "Hello" })));

  const find = scoped.notes.find({ where: { id: "1" }, limit: 1 });
  const inspected = await find.inspect();
  console.log("find sql:", inspected.sql.text);
  console.log("find params:", JSON.stringify(inspected.sql.params));
  console.log("find rule:", JSON.stringify(inspected.rules.find((rule) => rule.rule === "tenancy")));
  console.log("acme rows:", (await find).length);
  const other = db.for({ tenantId: globex });
  console.log("globex rows:", (await other.notes.find({ where: { id: "1" }, limit: 1 })).length);

  const update = await scoped.notes.update({ where: { id: "1" }, set: { title: "Hi" } }).sql();
  console.log("update sql:", update.statements[0]?.text);

  const shared = await db.plans.find({ limit: 1 }).inspect();
  console.log("plans sql:", shared.sql.text);
  console.log("plans rule:", JSON.stringify(shared.rules.find((rule) => rule.rule === "tenancy")));
}

insert: {"id":"1","title":"Hello","tenantId":"018f3b2c-7a11-7c3a-8e2d-6b4a9c1d0e5f"}
find sql: select t."id", t."title", t."tenantId" from "notes" t where t."tenantId" = $1 and t."id" = $2 limit $3
find params: ["018f3b2c-7a11-7c3a-8e2d-6b4a9c1d0e5f","1","1"]
find rule: {"rule":"tenancy","contribution":"scoped","provenance":"planner"}
acme rows: 1
globex rows: 0
update sql: update "notes" as t set "title" = $1::text where t."tenantId" = $2 and t."id" = $3
plans sql: select t."id", t."code" from "plans" t limit $1
plans rule: {"rule":"tenancy","contribution":"global plans are shared","provenance":"catalog","source":"tenancy-model.ts:6"}

create table "public"."notes" (
  "id" bigint generated always as identity not null,
  "tenantId" uuid not null,
  "title" text not null,
  constraint "notes_pkey" primary key ("id", "tenantId")
);

alter table "public"."notes" add constraint "notes_id_tenantId_key" unique ("id", "tenantId");

create table "public"."plans" (
  "code" text not null,
  "id" bigint generated always as identity not null,
  constraint "plans_pkey" primary key ("id")
);

import { connect } from "okmodel/pg/postgresjs";
import { compositeTenancy } from "okmodel/tenancy";
import { schema, table, t } from "okmodel/pg";

const documents = table("documents", {
  id: t.identity(),
  title: t.text(),
});

const app = schema({
  tables: [documents],
  tenancy: compositeTenancy({
    key: ["organizationId", "workspaceId"],
    type: "uuid",
  }),
});

export async function add(url: string, organizationId: string, workspaceId: string, title: string) {
  await using db = connect(url, { schema: app });
  return await db.for({ organizationId, workspaceId }).documents.insert({ title });
}

import { rlsTenancy } from "okmodel/tenancy";
import { schema, table, t } from "okmodel/pg";

const notes = table("notes", {
  id: t.identity(),
  title: t.text(),
});

export default schema({
  tables: [notes],
  tenancy: rlsTenancy({ key: "tenantId", type: "uuid" }),
});

import { connect } from "okmodel/pg/postgresjs";
import { one, schema, table, t } from "okmodel/pg";
import { columnTenancy, via } from "okmodel/tenancy";

const organizations = table("organizations", {
  id: t.identity(),
  name: t.text(),
});

const projects = table(
  "projects",
  {
    id: t.identity(),
    organizationId: t.bigint().references("organizations"),
    name: t.text(),
  },
  {
    relations: { organization: one("organizations") },
    tenancy: via("organization"),
  },
);

const tasks = table(
  "tasks",
  {
    id: t.identity(),
    projectId: t.bigint().references("projects"),
    title: t.text(),
  },
  {
    relations: { project: one("projects") },
    tenancy: via("project.organization"),
  },
);

const app = schema({
  tables: [organizations, projects, tasks],
  tenancy: columnTenancy({ key: "tenantId", type: "uuid" }),
});

export async function open(url: string) {
  await using db = connect(url, { schema: app });
  const scoped = db.for({ tenantId: "018f3b2c-7a11-7c3a-8e2d-6b4a9c1d0e5f" });
  const org = await scoped.organizations.insert({ name: "Acme" });
  const project = await scoped.projects.insert({ name: "Ship", organizationId: org.id });
  return await scoped.tasks.insert({ title: "Write", projectId: project.id });
}

import { table, t } from "okmodel/pg";

export const notes = table("notes", {
  id: t.identity(),
  email: t.text().unique({ global: "login email" }),
  title: t.text().unique(),
});

import { columnTenancy } from "okmodel/tenancy";
import { index, schema, table, t } from "okmodel/pg";

const notes = table(
  "notes",
  { id: t.identity(), email: t.text(), title: t.text() },
  {
    indexes: (columns) => [
      index(columns.email).unique(),
      index(columns.title).global("shared title"),
    ],
  },
);

export default schema({
  tenancy: columnTenancy({ key: "tenantId", type: "uuid" }),
  tables: [notes],
});