better-supabase 0.0.0 → 0.1.0

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+import { a as BrowserOptions, i as BrowserAuth, n as AuthUser, o as createBrowser, r as BetterBrowser, t as AuthSnapshot } from "../index-Sw43J8HG.js";
+export { AuthSnapshot, AuthUser, BetterBrowser, BrowserAuth, BrowserOptions, createBrowser };

package/dist/client/index.js

@@ -0,0 +1,112 @@
+import { a as parseEnv, n as EnvValidationError } from "../env-BEToab0I.js";
+import { t as createQueries } from "../query-ChvDbsDE.js";
+import { createBrowserClient } from "@supabase/ssr";
+import { createClient } from "@supabase/supabase-js";
+//#region src/client/index.ts
+const LOADING = {
+	status: "loading",
+	user: null,
+	claims: null
+};
+const SIGNED_OUT = {
+	status: "signed-out",
+	user: null,
+	claims: null
+};
+function decodeClaims(token) {
+	const part = token.split(".")[1];
+	if (!part) return {};
+	try {
+		const bytes = Uint8Array.from(atob(part.replace(/-/g, "+").replace(/_/g, "/")), (char) => char.charCodeAt(0));
+		const parsed = JSON.parse(new TextDecoder().decode(bytes));
+		return typeof parsed === "object" && parsed !== null ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function snapshotOf(session) {
+	if (!session) return SIGNED_OUT;
+	const claims = decodeClaims(session.access_token);
+	const role = typeof claims["role"] === "string" ? claims["role"] : session.user.role;
+	return {
+		status: "signed-in",
+		user: {
+			id: session.user.id,
+			...session.user.email ? { email: session.user.email } : {},
+			...role ? { role } : {}
+		},
+		claims
+	};
+}
+function contextOf(snapshot) {
+	if (snapshot.status !== "signed-in") return {
+		actor: {
+			id: "anon",
+			kind: "anon",
+			role: "anon"
+		},
+		claims: { role: "anon" }
+	};
+	return {
+		actor: {
+			id: snapshot.user.id,
+			kind: "user",
+			...snapshot.user.role ? { role: snapshot.user.role } : {},
+			...snapshot.user.email ? { email: snapshot.user.email } : {}
+		},
+		claims: snapshot.claims
+	};
+}
+function clientFor(options) {
+	if (options.client) return options.client;
+	if (!options.env) throw new TypeError("createBrowser needs `env` ({ url, publishableKey }) or `client`");
+	const checked = parseEnv({
+		SUPABASE_URL: options.env.url,
+		SUPABASE_PUBLISHABLE_KEY: options.env.publishableKey
+	});
+	if (!checked.ok) throw new EnvValidationError(checked.issues);
+	if (options.storage === "local") return createClient(checked.env.url, checked.env.publishableKey);
+	return createBrowserClient(checked.env.url, checked.env.publishableKey);
+}
+/**
+* The browser side: a supabase-js client, repositories that follow the
+* session, TanStack Query options and an auth store for UI state.
+*
+* ```ts
+* export const browser = createBrowser(sb, { env: { url, publishableKey } });
+* ```
+*/
+function createBrowser(sb, options = {}) {
+	const supabase = clientFor(options);
+	let snapshot = LOADING;
+	let db;
+	const listeners = /* @__PURE__ */ new Set();
+	supabase.auth.onAuthStateChange((_event, session) => {
+		const next = snapshotOf(session);
+		if (!(next.status !== snapshot.status || next.user?.id !== snapshot.user?.id || next.status === "signed-in" && snapshot.status === "signed-in" && next.claims["exp"] !== snapshot.claims["exp"])) return;
+		snapshot = next;
+		db = void 0;
+		for (const listener of listeners) listener();
+	});
+	const browser = {
+		sb,
+		supabase,
+		get db() {
+			db ??= sb.connect(supabase, contextOf(snapshot));
+			return db;
+		},
+		queries: createQueries(sb, () => browser.db),
+		auth: {
+			current: () => snapshot,
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			}
+		}
+	};
+	return browser;
+}
+//#endregion
+export { createBrowser };

package/dist/compiler-DL18ukPe.d.ts

@@ -0,0 +1,14 @@
+import { g as Operation } from "./executor-Bazhgsgq.js";
+import { i as PostgrestPlan } from "./postgrest-Dm-vhY6R.js";
+//#region src/core/compiler.d.ts
+/**
+ * Turns an IR operation into something a backend runs. An `Executor` for a
+ * new backend usually pairs with a `Compiler` for it.
+ */
+interface Compiler<TTarget> {
+  readonly target: string;
+  compile(op: Operation): TTarget;
+}
+declare const postgrestCompiler: Compiler<PostgrestPlan>;
+//#endregion
+export { postgrestCompiler as n, Compiler as t };

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+import { A as resolveConfig, C as SqlConfig, D as VectorDistance, E as TimestampsConfig, F as valibot, I as JsonSchemaGeneratorOptions, L as buildJsonSchema, M as ZodGeneratorOptions, N as zod, O as VectorSearchConfig, P as ValibotGeneratorOptions, R as jsonSchema, S as SourceConfig, T as TenantConfig, _ as RealtimeConfig, a as CodecsConfig, b as SeedConfig, c as ExposeConfig, d as GeneratorInput, f as JsonSchemaSource, g as Privilege, h as PluginFlagsConfig, i as CONFIG_SCHEMA_URL, j as resolveJsonSchema, k as defineConfig, l as GeneratedFile, m as OpenApiConfig, n as BetterSupabaseConfig, o as DoctorConfig, p as JsonTypeConfig, r as BucketConfig, s as EntitlementsConfig, t as ActorConfig, u as Generator, v as ResolvedConfig, w as TableConfig, x as SoftDeleteConfig, y as ResolvedExpose } from "../index-BD6wKthp.js";
+import { i as Casing } from "../types-C2fslP1z.js";
+export { ActorConfig, BetterSupabaseConfig, BucketConfig, CONFIG_SCHEMA_URL, type Casing, CodecsConfig, DoctorConfig, EntitlementsConfig, ExposeConfig, GeneratedFile, Generator, GeneratorInput, type JsonSchemaGeneratorOptions, JsonSchemaSource, JsonTypeConfig, OpenApiConfig, PluginFlagsConfig, Privilege, RealtimeConfig, ResolvedConfig, ResolvedExpose, SeedConfig, SoftDeleteConfig, SourceConfig, SqlConfig, TableConfig, TenantConfig, TimestampsConfig, type ValibotGeneratorOptions, VectorDistance, VectorSearchConfig, type ZodGeneratorOptions, buildJsonSchema, defineConfig, jsonSchema, resolveConfig, resolveJsonSchema, valibot, zod };

package/dist/config/index.js

@@ -0,0 +1,3 @@
+import { n as jsonSchema, t as buildJsonSchema } from "../json-schema-BbwO2mZg.js";
+import { a as zod, i as resolveJsonSchema, n as defineConfig, o as valibot, r as resolveConfig, t as CONFIG_SCHEMA_URL } from "../config-D-aR2ZoN.js";
+export { CONFIG_SCHEMA_URL, buildJsonSchema, defineConfig, jsonSchema, resolveConfig, resolveJsonSchema, valibot, zod };

package/dist/config-D-aR2ZoN.js

@@ -0,0 +1,276 @@
+import { a as parseImport, c as schemaName, d as variantsFor, i as fieldsFor, l as siblingPath, o as propertyKey, r as HEADER, s as rowType, u as tableEntries } from "./json-schema-BbwO2mZg.js";
+//#region src/generators/valibot.ts
+function scalar$1(kind) {
+	switch (kind.kind) {
+		case "uuid": return "v.pipe(v.string(), v.uuid())";
+		case "string": return "v.string()";
+		case "integer": return "v.pipe(v.number(), v.integer())";
+		case "number": return "v.number()";
+		case "boolean": return "v.boolean()";
+		case "datetime": return "v.pipe(v.string(), v.isoTimestamp())";
+		case "date": return "v.pipe(v.string(), v.isoDate())";
+		case "dateObject": return "v.date()";
+		case "bigint": return "v.bigint()";
+		case "json": return "json";
+		case "enum": return `v.picklist([${kind.values.map((value) => JSON.stringify(value)).join(", ")}])`;
+		case "unknown": return "v.unknown()";
+		default: return kind;
+	}
+}
+function field$1(table, plan, jsonImports) {
+	const imported = jsonImports.get(`${table}.${plan.column.db}`);
+	let expr = imported ? imported : plan.customJson ? `v.custom<NonNullable<RowOf<'${table}'>['${plan.name}']>>((value) => value !== undefined)` : plan.column.storage !== void 0 ? `(v.string() as unknown as v.GenericSchema<${rowType(table, plan)}>)` : scalar$1(plan.scalar);
+	if (plan.column.array) expr = `v.array(${expr})`;
+	if (plan.nullable) expr = `v.nullable(${expr})`;
+	if (plan.optional) expr = `v.exactOptional(${expr})`;
+	return `  ${propertyKey(plan.name)}: ${expr},`;
+}
+/** Valibot schemas for every table's Row, Insert and Update shape. */
+function valibot(options = {}) {
+	return {
+		name: "valibot",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "valibot.ts");
+			const imports = /* @__PURE__ */ new Map();
+			const jsonImports = /* @__PURE__ */ new Map();
+			const tableNames = new Map(Object.values(input.meta.tables).map((t) => [t.name, t.key]));
+			for (const [key, spec] of Object.entries(options.json ?? {})) {
+				const [tableName, column] = key.split(".");
+				const { from, name } = parseImport(spec);
+				const specifier = from.startsWith(".") ? input.importPath(path, from) : from;
+				imports.set(specifier, [...imports.get(specifier) ?? [], name]);
+				jsonImports.set(`${tableNames.get(tableName ?? "") ?? tableName}.${column}`, name);
+			}
+			const lines = [
+				HEADER,
+				"import * as v from \"valibot\";",
+				""
+			];
+			lines.push(`import type { InsertOf, Json, RowOf, UpdateOf } from ${JSON.stringify(input.importPath(path, input.config.output))};`);
+			for (const [from, names] of imports) lines.push(`import { ${[...new Set(names)].sort().join(", ")} } from ${JSON.stringify(from)};`);
+			lines.push("", "const json: v.GenericSchema<Json> = v.lazy(() =>", "  v.union([v.string(), v.number(), v.boolean(), v.null(), v.array(json), v.record(v.string(), v.optional(json))]),", ");");
+			const validators = [];
+			const validatorTypes = [];
+			for (const [key, table] of tableEntries(input)) {
+				lines.push("");
+				const variants = variantsFor(table);
+				for (const variant of variants) {
+					const name = schemaName(key, variant);
+					lines.push(`export const ${name}: v.GenericSchema<${variant}Of<'${key}'>> = v.object({`);
+					for (const plan of fieldsFor(table, variant, input)) lines.push(field$1(key, plan, jsonImports));
+					lines.push("});");
+				}
+				if (variants.includes("Insert")) {
+					const insert = schemaName(key, "Insert");
+					const update = schemaName(key, "Update");
+					validators.push(`  ${propertyKey(key)}: { insert: ${insert}, update: ${update} },`);
+					validatorTypes.push(`  readonly ${propertyKey(key)}: { readonly insert: typeof ${insert}; readonly update: typeof ${update} };`);
+				}
+			}
+			lines.push("", "/** Write validators for the validation plugin. */");
+			lines.push("export const validators: {", ...validatorTypes, "} = {", ...validators, "};", "");
+			return [{
+				path,
+				contents: lines.join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/generators/zod.ts
+function scalar(kind) {
+	switch (kind.kind) {
+		case "uuid": return "z.guid()";
+		case "string": return "z.string()";
+		case "integer": return "z.int()";
+		case "number": return "z.number()";
+		case "boolean": return "z.boolean()";
+		case "datetime": return "z.iso.datetime({ offset: true })";
+		case "date": return "z.iso.date()";
+		case "dateObject": return "z.date()";
+		case "bigint": return "z.bigint()";
+		case "json": return "z.json()";
+		case "enum": return `z.enum([${kind.values.map((value) => JSON.stringify(value)).join(", ")}])`;
+		case "unknown": return "z.unknown()";
+		default: return kind;
+	}
+}
+function field(table, plan, jsonImports) {
+	const imported = jsonImports.get(`${table}.${plan.column.db}`);
+	let expr = imported ? imported : plan.customJson ? `z.custom<NonNullable<RowOf<'${table}'>['${plan.name}']>>((value) => value !== undefined)` : plan.column.storage !== void 0 ? `(z.string() as unknown as z.ZodType<${rowType(table, plan)}>)` : scalar(plan.scalar);
+	if (plan.column.array) expr = `z.array(${expr})`;
+	if (plan.nullable) expr = `${expr}.nullable()`;
+	if (plan.optional) expr = `${expr}.exactOptional()`;
+	return `  ${propertyKey(plan.name)}: ${expr},`;
+}
+/** Zod 4 schemas for every table's Row, Insert and Update shape. */
+function zod(options = {}) {
+	return {
+		name: "zod",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "zod.ts");
+			const imports = /* @__PURE__ */ new Map();
+			const jsonImports = /* @__PURE__ */ new Map();
+			const tableNames = new Map(Object.values(input.meta.tables).map((t) => [t.name, t.key]));
+			for (const [key, spec] of Object.entries(options.json ?? {})) {
+				const [tableName, column] = key.split(".");
+				const { from, name } = parseImport(spec);
+				const specifier = from.startsWith(".") ? input.importPath(path, from) : from;
+				imports.set(specifier, [...imports.get(specifier) ?? [], name]);
+				jsonImports.set(`${tableNames.get(tableName ?? "") ?? tableName}.${column}`, name);
+			}
+			const lines = [
+				HEADER,
+				"import { z } from \"zod\";",
+				""
+			];
+			lines.push(`import type { InsertOf, RowOf, UpdateOf } from ${JSON.stringify(input.importPath(path, input.config.output))};`);
+			for (const [from, names] of imports) lines.push(`import { ${[...new Set(names)].sort().join(", ")} } from ${JSON.stringify(from)};`);
+			const validators = [];
+			for (const [key, table] of tableEntries(input)) {
+				lines.push("");
+				const variants = variantsFor(table);
+				for (const variant of variants) {
+					const name = schemaName(key, variant);
+					lines.push(`export const ${name}: z.ZodType<${variant}Of<'${key}'>> = z.object({`);
+					for (const plan of fieldsFor(table, variant, input)) lines.push(field(key, plan, jsonImports));
+					lines.push("});");
+				}
+				if (variants.includes("Insert")) validators.push(`  ${propertyKey(key)}: { insert: ${schemaName(key, "Insert")}, update: ${schemaName(key, "Update")} },`);
+			}
+			lines.push("", "/** Write validators for the validation plugin. */");
+			lines.push("export const validators: {");
+			for (const [key, table] of tableEntries(input)) {
+				if (!variantsFor(table).includes("Insert")) continue;
+				lines.push(`  readonly ${propertyKey(key)}: { readonly insert: typeof ${schemaName(key, "Insert")}; readonly update: typeof ${schemaName(key, "Update")} };`);
+			}
+			lines.push("} = {", ...validators, "};", "");
+			return [{
+				path,
+				contents: lines.join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/config/index.ts
+/** The JSON Schema document for a `json[...].schema` entry. */
+function resolveJsonSchema(source) {
+	const standard = source["~standard"];
+	if (standard === void 0) return source;
+	const jsonSchema = standard.jsonSchema;
+	if (typeof jsonSchema?.input !== "function") throw new TypeError("json[...].schema: this Standard Schema library does not implement Standard JSON Schema; pass a JSON Schema object instead");
+	return jsonSchema.input({ target: "draft-2020-12" });
+}
+function entitlementsOf(config = {}) {
+	const customer = config.customer ?? "organizations.stripe_customer_id";
+	const dot = customer.lastIndexOf(".");
+	if (dot <= 0) throw new TypeError(`entitlements.customer must be "table.column", got "${customer}"`);
+	return {
+		table: customer.slice(0, dot),
+		column: customer.slice(dot + 1),
+		key: config.key ?? "id"
+	};
+}
+function vectorSearchOf(config = {}) {
+	return Object.entries(config).map(([table, entry]) => typeof entry === "string" ? {
+		table,
+		column: entry,
+		distance: "cosine"
+	} : {
+		table,
+		column: entry.column,
+		distance: entry.distance ?? "cosine"
+	});
+}
+const CONFIG_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/config-v1.json";
+/** Identity helper that types `better-supabase.config.ts`. */
+function defineConfig(config) {
+	return config;
+}
+function pick(value, defaults) {
+	if (value === void 0 || value === false) return void 0;
+	if (value === true) return defaults;
+	return {
+		...defaults,
+		...value
+	};
+}
+function resolveExpose(entry) {
+	if (Array.isArray(entry)) return {
+		anon: [],
+		authenticated: entry
+	};
+	const roles = entry;
+	return {
+		anon: roles.anon ?? [],
+		authenticated: roles.authenticated ?? []
+	};
+}
+/** Applies defaults. Paths stay relative to `root`. */
+function resolveConfig(config, root) {
+	const output = config.output ?? "src/lib/supabase/generated.ts";
+	return {
+		root,
+		source: config.source ?? {},
+		schemas: config.schemas ?? ["public"],
+		casing: config.casing ?? "snake",
+		tables: config.tables ?? {},
+		output,
+		databaseTypesOutput: output.replace(/[^/]+$/, "database.types.ts"),
+		postgrestVersion: config.postgrestVersion ?? "13",
+		json: config.json ?? {},
+		codecs: {
+			timestamptz: config.codecs?.timestamptz ?? "string",
+			int8: config.codecs?.int8 ?? "number",
+			numeric: config.codecs?.numeric ?? "number"
+		},
+		sensitive: config.sensitive ?? [],
+		storagePaths: config.storagePaths ?? {},
+		expose: Object.fromEntries(Object.entries(config.expose ?? {}).map(([table, entry]) => [table, resolveExpose(entry)])),
+		readSets: config.readSets ?? [],
+		generators: config.generators ?? [],
+		plugins: {
+			timestamps: pick(config.plugins?.timestamps, {
+				createdAt: "created_at",
+				updatedAt: "updated_at"
+			}),
+			softDelete: pick(config.plugins?.softDelete, { column: "deleted_at" }),
+			tenant: pick(config.plugins?.tenant, {
+				column: "organization_id",
+				claim: "org_id"
+			}),
+			actor: pick(config.plugins?.actor, {
+				createdBy: "created_by",
+				updatedBy: "updated_by"
+			})
+		},
+		buckets: config.buckets ?? {},
+		topics: config.topics ?? {},
+		realtime: { tables: config.realtime?.tables ?? [] },
+		entitlements: entitlementsOf(config.entitlements),
+		vectorSearch: vectorSearchOf(config.vectorSearch),
+		sql: {
+			dir: config.sql?.dir ?? "supabase/schemas",
+			prefix: config.sql?.prefix ?? "900_better_supabase",
+			testsDir: config.sql?.testsDir ?? "supabase/tests",
+			kit: config.sql?.kit ?? []
+		},
+		seed: {
+			entry: config.seed?.entry ?? "supabase/seed.ts",
+			output: config.seed?.output ?? "supabase/seeds/000_better_supabase.sql"
+		},
+		openapi: {
+			entry: config.openapi?.entry ?? "src/lib/openapi.ts",
+			output: config.openapi?.output ?? "openapi.json"
+		},
+		doctor: {
+			ignore: config.doctor?.ignore ?? [],
+			strict: config.doctor?.strict ?? false,
+			sources: config.doctor?.sources ?? ["src/**/*.{ts,tsx}"],
+			policyHelperLimit: config.doctor?.policyHelperLimit ?? 5
+		}
+	};
+}
+//#endregion
+export { zod as a, resolveJsonSchema as i, defineConfig as n, valibot as o, resolveConfig as r, CONFIG_SCHEMA_URL as t };