better-supabase 0.0.0 → 0.1.0

package/dist/json-schema-BbwO2mZg.js

@@ -0,0 +1,181 @@
+//#region src/generators/shared.ts
+const INTEGER = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8"
+]);
+const NUMBER = /* @__PURE__ */ new Set([
+	"float4",
+	"float8",
+	"numeric",
+	"oid",
+	"money"
+]);
+const DATETIME = /* @__PURE__ */ new Set(["timestamptz"]);
+function scalarKind(column) {
+	if (column.enum) return {
+		kind: "enum",
+		values: column.enum
+	};
+	if (column.json) return { kind: "json" };
+	if (column.codec === "date") return { kind: "dateObject" };
+	if (column.codec === "bigint") return { kind: "bigint" };
+	if (column.codec === "string") return { kind: "string" };
+	if (column.type === "uuid") return { kind: "uuid" };
+	if (INTEGER.has(column.type)) return { kind: "integer" };
+	if (NUMBER.has(column.type)) return { kind: "number" };
+	if (column.type === "bool") return { kind: "boolean" };
+	if (DATETIME.has(column.type)) return { kind: "datetime" };
+	if (column.type === "date") return { kind: "date" };
+	if (column.type === "record" || column.type === "void") return { kind: "unknown" };
+	return { kind: "string" };
+}
+/**
+* The generated row type of a field (its element type for arrays). Storage
+* path columns validate as strings and are cast to their `StoragePath` brand.
+*/
+function rowType(table, plan) {
+	const type = `NonNullable<RowOf<'${table}'>['${plan.name}']>`;
+	return plan.column.array ? `${type}[number]` : type;
+}
+/** The fields a variant accepts; read-only columns are left out of writes. */
+function fieldsFor(table, variant, input) {
+	const fields = [];
+	for (const [name, column] of Object.entries(table.columns)) {
+		if (variant === "Insert" && (column.generated || column.insertable === false)) continue;
+		if (variant === "Update" && (column.generated || column.updatable === false)) continue;
+		fields.push({
+			name,
+			column,
+			scalar: scalarKind(column),
+			nullable: column.nullable,
+			optional: variant === "Update" || variant === "Insert" && (column.nullable || column.hasDefault),
+			customJson: Boolean(column.json && input.config.json[`${table.name}.${column.db}`])
+		});
+	}
+	return fields;
+}
+function variantsFor(table) {
+	return table.kind === "view" ? ["Row"] : [
+		"Row",
+		"Insert",
+		"Update"
+	];
+}
+function tableEntries(input) {
+	return Object.entries(input.meta.tables).sort(([a], [b]) => a.localeCompare(b));
+}
+function propertyKey(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+/** `customerTags` + `Insert` → `customerTagsInsert`. */
+function schemaName(table, variant) {
+	return `${table.replace(/^[A-Z]/, (c) => c.toLowerCase())}${variant}`;
+}
+/** Output path next to the main module: `generated.ts` → `generated.zod.ts`. */
+function siblingPath(output, suffix) {
+	return output.replace(/(\.[cm]?ts)?$/, `.${suffix}`);
+}
+const HEADER = "// Generated by better-supabase. Do not edit; run `better-supabase gen`.\n";
+/** `./metadata.ts#metadataSchema` → `{ from: './metadata.ts', name: 'metadataSchema' }`. */
+function parseImport(spec) {
+	const [from, name] = spec.split("#");
+	if (!from || !name) throw new Error(`Expected "path#export", got "${spec}"`);
+	return {
+		from,
+		name
+	};
+}
+//#endregion
+//#region src/generators/json-schema.ts
+function scalar(kind) {
+	switch (kind.kind) {
+		case "uuid": return {
+			type: "string",
+			format: "uuid"
+		};
+		case "string": return { type: "string" };
+		case "integer": return { type: "integer" };
+		case "number": return { type: "number" };
+		case "boolean": return { type: "boolean" };
+		case "datetime": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "date": return {
+			type: "string",
+			format: "date"
+		};
+		case "dateObject": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "bigint": return {
+			type: "string",
+			pattern: "^-?\\d+$"
+		};
+		case "json":
+		case "unknown": return {};
+		case "enum": return {
+			type: "string",
+			enum: [...kind.values]
+		};
+		default: return kind;
+	}
+}
+function property(plan) {
+	let schema = scalar(plan.scalar);
+	if (plan.column.array) schema = {
+		type: "array",
+		items: schema
+	};
+	if (!plan.nullable) return schema;
+	if (Object.keys(schema).length === 0) return schema;
+	const { enum: values, ...rest } = schema;
+	if (Array.isArray(values)) return {
+		...rest,
+		type: ["string", "null"],
+		enum: [...values, null]
+	};
+	return typeof schema["type"] === "string" ? {
+		...schema,
+		type: [schema["type"], "null"]
+	} : { anyOf: [schema, { type: "null" }] };
+}
+/** JSON Schema (2020-12) `$defs` for every table: `customersRow`, `customersInsert`, ... */
+function buildJsonSchema(input, id) {
+	const defs = {};
+	for (const [key, table] of tableEntries(input)) for (const variant of variantsFor(table)) {
+		const properties = {};
+		const required = [];
+		for (const plan of fieldsFor(table, variant, input)) {
+			properties[plan.name] = property(plan);
+			if (!plan.optional) required.push(plan.name);
+		}
+		defs[`${key}${variant}`] = {
+			type: "object",
+			properties,
+			...required.length > 0 ? { required } : {},
+			additionalProperties: false
+		};
+	}
+	return {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		...id ? { $id: id } : {},
+		$defs: defs
+	};
+}
+/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
+function jsonSchema(options = {}) {
+	return {
+		name: "json-schema",
+		generate(input) {
+			return [{
+				path: options.output ?? siblingPath(input.config.output, "schema.json"),
+				contents: `${JSON.stringify(buildJsonSchema(input, options.id), null, 2)}\n`
+			}];
+		}
+	};
+}
+//#endregion
+export { parseImport as a, schemaName as c, variantsFor as d, fieldsFor as i, siblingPath as l, jsonSchema as n, propertyKey as o, HEADER as r, rowType as s, buildJsonSchema as t, tableEntries as u };

package/dist/lint/index.d.ts

@@ -0,0 +1,75 @@
+//#region src/lint/index.d.ts
+/**
+ * Static checks for better-supabase calls, written against the ESLint rule
+ * API so it loads in ESLint (flat config) and in oxlint's `jsPlugins`:
+ *
+ * ```js
+ * import betterSupabase from 'better-supabase/lint';
+ * export default [betterSupabase.configs.recommended];
+ * ```
+ *
+ * Rules match calls by method name (`.findMany(...)`, `.deleteMany(...)`)
+ * with an inline object literal; spread or variable arguments are skipped
+ * rather than guessed at. The runtime `rules()` plugin covers the rest.
+ */
+interface Node {
+  readonly type: string;
+}
+export interface CallExpression extends Node {
+  readonly type: "CallExpression";
+  readonly callee: Node;
+  readonly arguments: readonly Node[];
+}
+export interface RuleContext {
+  readonly options: readonly unknown[];
+  report(descriptor: {
+    readonly node: Node;
+    readonly messageId: string;
+    readonly data?: Readonly<Record<string, string>>;
+  }): void;
+}
+export interface RuleModule {
+  readonly meta: {
+    readonly type: "problem" | "suggestion";
+    readonly docs: {
+      readonly description: string;
+      readonly url: string;
+    };
+    readonly messages: Readonly<Record<string, string>>;
+    readonly schema: readonly unknown[];
+  };
+  create(context: RuleContext): {
+    CallExpression(node: CallExpression): void;
+  };
+}
+export type RuleId = "no-unbounded-find-many" | "no-delete-many-without-where" | "max-limit" | "require-order-by" | "unbounded-read";
+/** The part of `supabase/snapshot.json` that `largeTables` reads. */
+export interface LintSnapshot {
+  readonly extras: {
+    readonly tables: readonly {
+      readonly schema: string;
+      readonly name: string;
+      readonly large?: boolean;
+    }[];
+  };
+}
+/**
+ * The tables `gen` marked as large (an estimated 10,000 rows or more), as
+ * `schema.name`, for the `unbounded-read` rule's `tables` option.
+ */
+export declare function largeTables(snapshot: LintSnapshot): string[];
+export declare const rules: Readonly<Record<RuleId, RuleModule>>;
+export declare const plugin: {
+  readonly meta: {
+    readonly name: string;
+  };
+  readonly rules: Readonly<Record<RuleId, RuleModule>>;
+  readonly configs: {
+    readonly recommended: {
+      readonly plugins: Record<string, unknown>;
+      readonly rules: Readonly<Partial<Record<`better-supabase/${RuleId}`, "warn" | "error">>>;
+    };
+  };
+};
+//#endregion
+export { plugin as default };

package/dist/lint/index.js

@@ -0,0 +1,167 @@
+//#region src/lint/index.ts
+const DOCS = "https://bettersupabase.com/docs/plugins/lint";
+function methodName(node) {
+	const callee = node.callee;
+	if (callee.type !== "MemberExpression") return void 0;
+	const member = callee;
+	if (member.computed || member.property.type !== "Identifier") return void 0;
+	return member.property.name;
+}
+/** `users` in `db.users.findMany(...)`. */
+function receiverName(node) {
+	const callee = node.callee;
+	if (callee.object.type !== "MemberExpression") return void 0;
+	const receiver = callee.object;
+	if (receiver.computed || receiver.property.type !== "Identifier") return void 0;
+	return receiver.property.name;
+}
+/** Matches `order_items`, `orderItems` and `public.order_items` alike. */
+const tableKey = (name) => (name.split(".").at(-1) ?? name).replace(/_/g, "").toLowerCase();
+function keyName(property) {
+	if (property.computed) return void 0;
+	if (property.key.type === "Identifier") return property.key.name;
+	if (property.key.type === "Literal") {
+		const value = property.key.value;
+		return typeof value === "string" ? value : void 0;
+	}
+}
+/**
+* The call's first argument as a map of literal keys, `{}` when the call has
+* no arguments, or `undefined` when it cannot be read statically.
+*/
+function argsOf(node) {
+	const [first] = node.arguments;
+	if (first === void 0) return /* @__PURE__ */ new Map();
+	if (first.type !== "ObjectExpression") return void 0;
+	const keys = /* @__PURE__ */ new Map();
+	for (const property of first.properties) {
+		if (property.type !== "Property") return void 0;
+		const name = keyName(property);
+		if (name === void 0) return void 0;
+		keys.set(name, property.value);
+	}
+	return keys;
+}
+function numberOf(node) {
+	if (node?.type !== "Literal") return void 0;
+	const value = node.value;
+	return typeof value === "number" ? value : void 0;
+}
+function rule(description, name, messages, create, schema = []) {
+	return {
+		meta: {
+			type: "problem",
+			docs: {
+				description,
+				url: `${DOCS}#${name}`
+			},
+			messages,
+			schema
+		},
+		create
+	};
+}
+const FIND_METHODS = /* @__PURE__ */ new Set([
+	"findMany",
+	"findFirst",
+	"paginate"
+]);
+/**
+* The tables `gen` marked as large (an estimated 10,000 rows or more), as
+* `schema.name`, for the `unbounded-read` rule's `tables` option.
+*/
+function largeTables(snapshot) {
+	return snapshot.extras.tables.filter((table) => table.large === true).map((table) => `${table.schema}.${table.name}`);
+}
+const rules = {
+	"no-unbounded-find-many": rule("Require a limit on findMany", "no-unbounded-find-many", { unbounded: "findMany without limit reads every visible row." }, (context) => ({ CallExpression(node) {
+		if (methodName(node) !== "findMany") return;
+		const args = argsOf(node);
+		if (args && !args.has("limit")) context.report({
+			node,
+			messageId: "unbounded"
+		});
+	} })),
+	"no-delete-many-without-where": rule("Require where on deleteMany", "no-delete-many-without-where", { missing: "deleteMany without where removes every visible row." }, (context) => ({ CallExpression(node) {
+		if (methodName(node) !== "deleteMany") return;
+		const args = argsOf(node);
+		if (args && !args.has("where")) context.report({
+			node,
+			messageId: "missing"
+		});
+	} })),
+	"max-limit": rule("Cap literal limits", "max-limit", { tooLarge: "limit {{limit}} is above the maximum of {{max}}." }, (context) => {
+		const max = context.options[0]?.max ?? 1e3;
+		return { CallExpression(node) {
+			const method = methodName(node);
+			if (method === void 0 || !FIND_METHODS.has(method)) return;
+			const limit = numberOf(argsOf(node)?.get("limit"));
+			if (limit !== void 0 && limit > max) context.report({
+				node,
+				messageId: "tooLarge",
+				data: {
+					limit: String(limit),
+					max: String(max)
+				}
+			});
+		} };
+	}, [{
+		type: "object",
+		properties: { max: {
+			type: "integer",
+			minimum: 1
+		} },
+		additionalProperties: false
+	}]),
+	"require-order-by": rule("Require orderBy when paging with offset", "require-order-by", { unordered: "offset without orderBy returns rows in no stable order." }, (context) => ({ CallExpression(node) {
+		if (methodName(node) !== "findMany") return;
+		const args = argsOf(node);
+		if (args?.has("offset") && !args.has("orderBy")) context.report({
+			node,
+			messageId: "unordered"
+		});
+	} })),
+	"unbounded-read": rule("Require limit or paginate on large tables", "unbounded-read", { unbounded: "findMany on {{table}} without limit returns at most db-max-rows rows and drops the rest; add limit or use paginate()." }, (context) => {
+		const option = context.options[0];
+		const large = new Set((option?.tables ?? []).map(tableKey));
+		return { CallExpression(node) {
+			if (methodName(node) !== "findMany") return;
+			const table = receiverName(node);
+			if (table === void 0) return;
+			if (!option?.strict && !large.has(tableKey(table))) return;
+			const args = argsOf(node);
+			if (args && !args.has("limit")) context.report({
+				node,
+				messageId: "unbounded",
+				data: { table }
+			});
+		} };
+	}, [{
+		type: "object",
+		properties: {
+			tables: {
+				type: "array",
+				items: { type: "string" }
+			},
+			strict: { type: "boolean" }
+		},
+		additionalProperties: false
+	}])
+};
+const plugin = {
+	meta: { name: "better-supabase" },
+	rules,
+	configs: { recommended: {
+		plugins: {},
+		rules: {
+			"better-supabase/no-delete-many-without-where": "error",
+			"better-supabase/no-unbounded-find-many": "warn",
+			"better-supabase/max-limit": "warn",
+			"better-supabase/require-order-by": "warn",
+			"better-supabase/unbounded-read": "warn"
+		}
+	} }
+};
+plugin.configs.recommended.plugins["better-supabase"] = plugin;
+//#endregion
+export { plugin as default, plugin, largeTables, rules };

package/dist/list/index.d.ts

@@ -0,0 +1,2 @@
+import { a as ListPage, c as ListQuery, d as ListSearchParams, f as OpenApiParameter, h as defineListQuery, i as ListExtra, l as ListQueryConfig, m as UNSET, n as FacetInfo, o as ListParseResult, p as ParserSpec, r as ListDefinition, s as ListParsers, t as FacetCounts, u as ListQueryInput } from "../index-JXHBuS53.js";
+export { FacetCounts, FacetInfo, ListDefinition, ListExtra, ListPage, ListParseResult, ListParsers, ListQuery, ListQueryConfig, ListQueryInput, ListSearchParams, OpenApiParameter, ParserSpec, UNSET, defineListQuery };