oRPC

import { os } from "@orpc/server";
import { createOrpc, type OrpcRequestContext } from "better-supabase/orpc";
import * as v from "valibot";
import { betterSupabase } from "./lib/supabase";

export const bs = createOrpc(betterSupabase);

const base = os.$context<OrpcRequestContext>();
const authed = base.use(bs.middleware());
const open = base.use(bs.middleware({ allow: ["user", "anon"] }));

export const router = {
  customers: {
    list: authed.handler(({ context }) =>
      bs.unwrap(context.db.customers.findMany({ select: ["id", "name"] })),
    ),
    rename: authed
      .input(
        v.object({ id: v.string(), name: v.pipe(v.string(), v.minLength(2)) }),
      )
      .handler(({ input, context }) =>
        bs.unwrap(context.db.customers.update(input.id, { name: input.name })),
      ),
  },
  health: open.handler(() => ({ ok: true })),
};

import { RPCHandler } from "@orpc/server/fetch";

export default {
  fetch: bs.fetchHandler(new RPCHandler(router), { prefix: "/rpc" }),
};

import { RPCHandler } from "@orpc/server/fetch";
import { toOrpc } from "better-supabase/orpc";
import { createServer, withBetterSupabase } from "better-supabase/server";

const bs = createServer(betterSupabase);
// The router's procedures read context.db.
const base = os.$context<{
  request: Request;
  db: ReturnType<typeof bs.admin>;
}>();

export default {
  fetch: toOrpc([withBetterSupabase(bs)], new RPCHandler(router), {
    prefix: "/rpc",
  }),
};

import { oc } from "@orpc/contract";
import { openapi } from "@orpc/openapi";
import * as v from "valibot";

const customer = v.object({ id: v.string(), name: v.string() });

export const contract = {
  customers: {
    get: oc
      .meta(openapi({ method: "GET", path: "/customers/{id}" }))
      .input(v.object({ id: v.pipe(v.string(), v.uuid()) }))
      .output(customer),
  },
};

import { OpenAPIHandler } from "@orpc/openapi/fetch";
import { implement } from "@orpc/server";
import type { OrpcRequestContext } from "better-supabase/orpc";
import { Hono } from "hono";

import { contract } from "./contract";

const os = implement(contract)
  .$context<OrpcRequestContext>()
  .use(bs.middleware());

const router = os.router({
  customers: {
    get: os.customers.get.handler(({ context, input }) =>
      bs.unwrap(
        context.db.customers.findById(input.id, { select: ["id", "name"] }),
      ),
    ),
  },
});

const handle = bs.fetchHandler(new OpenAPIHandler(router), { prefix: "/api" });

export const app = new Hono().all("/api/*", (c) => handle(c.req.raw));

export const role = authed.handler(({ context }) =>
  context.auth.kind === "user" ? context.auth.claims.user_role : null,
);

import { createOrpc } from "better-supabase/orpc";
import * as v from "valibot";
import { authorizer } from "./lib/authorizer";
import { betterSupabase } from "./lib/supabase";

export const bs = createOrpc(betterSupabase, { authorizer });

export const remove = bs
  .authed({ requireTenant: true, permission: "customers.delete" })
  .input(v.object({ id: v.string() }))
  .handler(({ input, context }) =>
    bs.unwrap(context.db.customers.delete(input.id)),
  );

import { safe } from "@orpc/client";

const [error, data] = await safe(client.customers.rename({ id, name }));
if (error?.data?.kind === "conflict") showTaken(error.data.constraint);