@prisma-next/extension-supabase 0.12.0

package/dist/pack.mjs

@@ -0,0 +1,467 @@
+import { blindCast } from "@prisma-next/utils/casts";
+//#region package.json
+var version = "0.12.0";
+//#endregion
+//#region src/contract/contract.json
+var contract_default = {
+	schemaVersion: "1",
+	targetFamily: "sql",
+	target: "postgres",
+	profileHash: "sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb",
+	roots: {
+		"buckets": {
+			"model": "StorageBucket",
+			"namespace": "storage"
+		},
+		"identities": {
+			"model": "AuthIdentity",
+			"namespace": "auth"
+		},
+		"objects": {
+			"model": "StorageObject",
+			"namespace": "storage"
+		},
+		"users": {
+			"model": "AuthUser",
+			"namespace": "auth"
+		}
+	},
+	domain: { "namespaces": {
+		"auth": { "models": {
+			"AuthIdentity": {
+				"fields": {
+					"created_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					},
+					"id": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"provider": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"updated_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					},
+					"user_id": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					}
+				},
+				"relations": {},
+				"storage": {
+					"fields": {
+						"created_at": { "column": "created_at" },
+						"id": { "column": "id" },
+						"provider": { "column": "provider" },
+						"updated_at": { "column": "updated_at" },
+						"user_id": { "column": "user_id" }
+					},
+					"namespaceId": "auth",
+					"table": "identities"
+				}
+			},
+			"AuthUser": {
+				"fields": {
+					"created_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					},
+					"email": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"id": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"updated_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					}
+				},
+				"relations": {},
+				"storage": {
+					"fields": {
+						"created_at": { "column": "created_at" },
+						"email": { "column": "email" },
+						"id": { "column": "id" },
+						"updated_at": { "column": "updated_at" }
+					},
+					"namespaceId": "auth",
+					"table": "users"
+				}
+			}
+		} },
+		"storage": { "models": {
+			"StorageBucket": {
+				"fields": {
+					"created_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					},
+					"id": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"name": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"updated_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					}
+				},
+				"relations": {},
+				"storage": {
+					"fields": {
+						"created_at": { "column": "created_at" },
+						"id": { "column": "id" },
+						"name": { "column": "name" },
+						"updated_at": { "column": "updated_at" }
+					},
+					"namespaceId": "storage",
+					"table": "buckets"
+				}
+			},
+			"StorageObject": {
+				"fields": {
+					"bucket_id": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"created_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					},
+					"id": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"name": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/text@1",
+							"kind": "scalar"
+						}
+					},
+					"updated_at": {
+						"nullable": false,
+						"type": {
+							"codecId": "pg/timestamptz@1",
+							"kind": "scalar"
+						}
+					}
+				},
+				"relations": {},
+				"storage": {
+					"fields": {
+						"bucket_id": { "column": "bucket_id" },
+						"created_at": { "column": "created_at" },
+						"id": { "column": "id" },
+						"name": { "column": "name" },
+						"updated_at": { "column": "updated_at" }
+					},
+					"namespaceId": "storage",
+					"table": "objects"
+				}
+			}
+		} }
+	} },
+	storage: {
+		"namespaces": {
+			"__unbound__": {
+				"entries": { "table": {} },
+				"id": "__unbound__",
+				"kind": "postgres-unbound-schema"
+			},
+			"auth": {
+				"entries": { "table": {
+					"identities": {
+						"columns": {
+							"created_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							},
+							"id": {
+								"codecId": "pg/text@1",
+								"nativeType": "uuid",
+								"nullable": false,
+								"typeRef": "Uuid"
+							},
+							"provider": {
+								"codecId": "pg/text@1",
+								"nativeType": "text",
+								"nullable": false
+							},
+							"updated_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							},
+							"user_id": {
+								"codecId": "pg/text@1",
+								"nativeType": "uuid",
+								"nullable": false,
+								"typeRef": "Uuid"
+							}
+						},
+						"foreignKeys": [],
+						"indexes": [],
+						"primaryKey": { "columns": ["id"] },
+						"uniques": []
+					},
+					"users": {
+						"columns": {
+							"created_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							},
+							"email": {
+								"codecId": "pg/text@1",
+								"nativeType": "text",
+								"nullable": false
+							},
+							"id": {
+								"codecId": "pg/text@1",
+								"nativeType": "uuid",
+								"nullable": false,
+								"typeRef": "Uuid"
+							},
+							"updated_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							}
+						},
+						"foreignKeys": [],
+						"indexes": [],
+						"primaryKey": { "columns": ["id"] },
+						"uniques": []
+					}
+				} },
+				"id": "auth",
+				"kind": "postgres-schema"
+			},
+			"public": {
+				"entries": { "table": {} },
+				"id": "public",
+				"kind": "postgres-schema"
+			},
+			"storage": {
+				"entries": { "table": {
+					"buckets": {
+						"columns": {
+							"created_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							},
+							"id": {
+								"codecId": "pg/text@1",
+								"nativeType": "text",
+								"nullable": false
+							},
+							"name": {
+								"codecId": "pg/text@1",
+								"nativeType": "text",
+								"nullable": false
+							},
+							"updated_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							}
+						},
+						"foreignKeys": [],
+						"indexes": [],
+						"primaryKey": { "columns": ["id"] },
+						"uniques": []
+					},
+					"objects": {
+						"columns": {
+							"bucket_id": {
+								"codecId": "pg/text@1",
+								"nativeType": "text",
+								"nullable": false
+							},
+							"created_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							},
+							"id": {
+								"codecId": "pg/text@1",
+								"nativeType": "uuid",
+								"nullable": false,
+								"typeRef": "Uuid"
+							},
+							"name": {
+								"codecId": "pg/text@1",
+								"nativeType": "text",
+								"nullable": false
+							},
+							"updated_at": {
+								"codecId": "pg/timestamptz@1",
+								"nativeType": "timestamptz",
+								"nullable": false,
+								"typeRef": "Timestamptz"
+							}
+						},
+						"foreignKeys": [],
+						"indexes": [],
+						"primaryKey": { "columns": ["id"] },
+						"uniques": []
+					}
+				} },
+				"id": "storage",
+				"kind": "postgres-schema"
+			}
+		},
+		"storageHash": "sha256:13b530a9c9fb26912d97f8a05dea26634242de75fb4af6b29337e4e7c7712876",
+		"types": {
+			"Timestamptz": {
+				"codecId": "pg/timestamptz@1",
+				"kind": "codec-instance",
+				"nativeType": "timestamptz",
+				"typeParams": {}
+			},
+			"Uuid": {
+				"codecId": "pg/text@1",
+				"kind": "codec-instance",
+				"nativeType": "uuid",
+				"typeParams": {}
+			}
+		}
+	},
+	capabilities: {
+		"postgres": {
+			"distinctOn": true,
+			"jsonAgg": true,
+			"lateral": true,
+			"limit": true,
+			"orderBy": true,
+			"returning": true
+		},
+		"sql": {
+			"defaultInInsert": true,
+			"enums": true,
+			"lateral": true,
+			"returning": true
+		}
+	},
+	extensionPacks: {},
+	defaultControlPolicy: "external",
+	meta: {},
+	_generated: {
+		"warning": "⚠️  GENERATED FILE - DO NOT EDIT",
+		"message": "This file is automatically generated by \"prisma-next contract emit\".",
+		"regenerate": "To regenerate, run: prisma-next contract emit"
+	}
+};
+//#endregion
+//#region src/pack/index.ts
+const SUPABASE_SPACE_ID = "supabase";
+function buildContractSpace(contractOverride) {
+	const contract = blindCast(contractOverride ?? contract_default);
+	return {
+		contractJson: contract,
+		migrations: [],
+		headRef: {
+			hash: contract.storage.storageHash,
+			invariants: []
+		}
+	};
+}
+const supabasePackBase = {
+	kind: "extension",
+	id: SUPABASE_SPACE_ID,
+	familyId: "sql",
+	targetId: "postgres",
+	version,
+	contractSpace: buildContractSpace(),
+	create: () => ({
+		familyId: "sql",
+		targetId: "postgres"
+	})
+};
+const supabasePack = supabasePackBase;
+/**
+* Returns a pack using `contractOverride` in place of the shipped
+* `contract.json` when provided, otherwise returns the default pack.
+*
+* Intended for tests that need to drive the framework with a synthetic
+* contract while still exercising the full descriptor wiring.
+*/
+function supabasePackWith(options) {
+	if (options?.contractOverride === void 0) return supabasePack;
+	return {
+		...supabasePackBase,
+		contractSpace: buildContractSpace(options.contractOverride)
+	};
+}
+//#endregion
+export { supabasePack as default, supabasePackWith };
+
+//# sourceMappingURL=pack.mjs.map

package/dist/pack.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.mjs","names":["contractJson","packageJson.version"],"sources":["../package.json","../src/contract/contract.json","../src/pack/index.ts"],"sourcesContent":["","","import type { SqlControlExtensionDescriptor } from '@prisma-next/family-sql/control';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport packageJson from '../../package.json' with { type: 'json' };\nimport type { Contract } from '../contract/contract.d';\nimport contractJson from '../contract/contract.json' with { type: 'json' };\n\nconst SUPABASE_SPACE_ID = 'supabase' as const;\n\nfunction buildContractSpace(contractOverride?: unknown) {\n  const contract = blindCast<\n    Contract,\n    'JSON import narrowed to emitted Contract type; assertDescriptorSelfConsistency verifies the storageHash at load time'\n  >(contractOverride ?? contractJson);\n  return {\n    contractJson: contract,\n    migrations: [] as const,\n    headRef: { hash: contract.storage.storageHash, invariants: [] as const },\n  };\n}\n\nconst supabaseContractSpace = buildContractSpace();\n\nconst supabasePackBase = {\n  kind: 'extension' as const,\n  id: SUPABASE_SPACE_ID,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  version: packageJson.version,\n  contractSpace: supabaseContractSpace,\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n} satisfies SqlControlExtensionDescriptor<'postgres'>;\n\nexport const supabasePack: SqlControlExtensionDescriptor<'postgres'> = supabasePackBase;\n\n/**\n * Returns a pack using `contractOverride` in place of the shipped\n * `contract.json` when provided, otherwise returns the default pack.\n *\n * Intended for tests that need to drive the framework with a synthetic\n * contract while still exercising the full descriptor wiring.\n */\nexport function supabasePackWith(options?: {\n  contractOverride?: unknown;\n}): SqlControlExtensionDescriptor<'postgres'> {\n  if (options?.contractOverride === undefined) return supabasePack;\n  return {\n    ...supabasePackBase,\n    contractSpace: buildContractSpace(options.contractOverride),\n  };\n}\n\nexport default supabasePack;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AEMA,MAAM,oBAAoB;AAE1B,SAAS,mBAAmB,kBAA4B;CACtD,MAAM,WAAW,UAGf,oBAAoBA,gBAAY;CAClC,OAAO;EACL,cAAc;EACd,YAAY,CAAC;EACb,SAAS;GAAE,MAAM,SAAS,QAAQ;GAAa,YAAY,CAAC;EAAW;CACzE;AACF;AAIA,MAAM,mBAAmB;CACvB,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACDC;CACT,eAR4B,mBAQb;CACf,eAAe;EACb,UAAU;EACV,UAAU;CACZ;AACF;AAEA,MAAa,eAA0D;;;;;;;;AASvE,SAAgB,iBAAiB,SAEa;CAC5C,IAAI,SAAS,qBAAqB,KAAA,GAAW,OAAO;CACpD,OAAO;EACL,GAAG;EACH,eAAe,mBAAmB,QAAQ,gBAAgB;CAC5D;AACF"}

package/dist/runtime.d.mts

@@ -0,0 +1,7 @@
+import { SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
+
+//#region src/exports/runtime.d.ts
+declare const supabaseRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>;
+//#endregion
+export { supabaseRuntimeDescriptor as default };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"mappings":";;;cAeM,yBAAA,EAA2B,6BAA6B"}

package/dist/runtime.mjs

@@ -0,0 +1,19 @@
+//#region src/exports/runtime.ts
+const supabaseRuntimeDescriptor = {
+	kind: "extension",
+	id: "supabase",
+	version: "0.12.0",
+	familyId: "sql",
+	targetId: "postgres",
+	codecs: () => [],
+	create() {
+		return {
+			familyId: "sql",
+			targetId: "postgres"
+		};
+	}
+};
+//#endregion
+export { supabaseRuntimeDescriptor as default };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":["/**\n * Minimal M1 runtime descriptor for the Supabase extension.\n *\n * The Supabase pack contributes no runtime codec types or query operations in\n * M1 — `auth.*`/`storage.*` are external tables accessed via the stock\n * postgres runtime, not through a custom codec or operation surface. This\n * descriptor exists so the postgres runtime's contract-requirements check\n * (which verifies every `extensionPacks` entry in the emitted `contract.json`\n * has a matching runtime component) passes.\n *\n * TODO(M2): Replace with the real SupabaseRuntime that adds\n *   `asUser()`/`asAnon()` role-binding and the Supabase auth surface.\n */\nimport type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';\n\nconst supabaseRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: 'supabase',\n  version: '0.12.0',\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  codecs: () => [],\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport default supabaseRuntimeDescriptor;\n"],"mappings":";AAeA,MAAM,4BAAuE;CAC3E,MAAM;CACN,IAAI;CACJ,SAAS;CACT,UAAU;CACV,UAAU;CACV,cAAc,CAAC;CACf,SAAS;EACP,OAAO;GACL,UAAU;GACV,UAAU;EACZ;CACF;AACF"}

package/dist/test/utils.d.mts

@@ -0,0 +1,24 @@
+import { Client } from "pg";
+
+//#region test/supabase-bootstrap.d.ts
+/**
+ * Seeds the database with the external Supabase schemas and tables. The
+ * caller passes an already-connected `pg.Client` — this function does not
+ * open or close connections, so the same client can be reused across the
+ * test's other setup steps.
+ *
+ * Creates two schemas (`auth`, `storage`) and four tables whose columns
+ * exactly match the `@prisma-next/extension-supabase` contract:
+ *
+ * - `auth.users` — id uuid PK, email text, created_at timestamptz, updated_at timestamptz
+ * - `auth.identities` — id uuid PK, user_id uuid, provider text, created_at timestamptz, updated_at timestamptz
+ * - `storage.buckets` — id text PK, name text, created_at timestamptz, updated_at timestamptz
+ * - `storage.objects` — id uuid PK, bucket_id text, name text, created_at timestamptz, updated_at timestamptz
+ *
+ * Does NOT create Postgres roles or `auth.*` functions — those are added by
+ * the `postgres-rls` constituent.
+ */
+declare function bootstrapSupabaseShim(client: Client): Promise<void>;
+//#endregion
+export { bootstrapSupabaseShim };
+//# sourceMappingURL=utils.d.mts.map

package/dist/test/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/supabase-bootstrap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAoDsB,qBAAA,CAAsB,MAAA,EAAQ,MAAA,GAAS,OAAO"}

package/dist/test/utils.mjs

@@ -0,0 +1,64 @@
+//#region test/supabase-bootstrap.ts
+/**
+* Seeds the database with the external Supabase schemas and tables. The
+* caller passes an already-connected `pg.Client` — this function does not
+* open or close connections, so the same client can be reused across the
+* test's other setup steps.
+*
+* Creates two schemas (`auth`, `storage`) and four tables whose columns
+* exactly match the `@prisma-next/extension-supabase` contract:
+*
+* - `auth.users` — id uuid PK, email text, created_at timestamptz, updated_at timestamptz
+* - `auth.identities` — id uuid PK, user_id uuid, provider text, created_at timestamptz, updated_at timestamptz
+* - `storage.buckets` — id text PK, name text, created_at timestamptz, updated_at timestamptz
+* - `storage.objects` — id uuid PK, bucket_id text, name text, created_at timestamptz, updated_at timestamptz
+*
+* Does NOT create Postgres roles or `auth.*` functions — those are added by
+* the `postgres-rls` constituent.
+*/
+async function bootstrapSupabaseShim(client) {
+	await client.query("CREATE SCHEMA IF NOT EXISTS auth");
+	await client.query("CREATE SCHEMA IF NOT EXISTS storage");
+	await client.query(`
+    CREATE TABLE IF NOT EXISTS auth.users (
+      id          uuid        NOT NULL,
+      email       text        NOT NULL,
+      created_at  timestamptz NOT NULL,
+      updated_at  timestamptz NOT NULL,
+      PRIMARY KEY (id)
+    )
+  `);
+	await client.query(`
+    CREATE TABLE IF NOT EXISTS auth.identities (
+      id          uuid        NOT NULL,
+      user_id     uuid        NOT NULL,
+      provider    text        NOT NULL,
+      created_at  timestamptz NOT NULL,
+      updated_at  timestamptz NOT NULL,
+      PRIMARY KEY (id)
+    )
+  `);
+	await client.query(`
+    CREATE TABLE IF NOT EXISTS storage.buckets (
+      id          text        NOT NULL,
+      name        text        NOT NULL,
+      created_at  timestamptz NOT NULL,
+      updated_at  timestamptz NOT NULL,
+      PRIMARY KEY (id)
+    )
+  `);
+	await client.query(`
+    CREATE TABLE IF NOT EXISTS storage.objects (
+      id          uuid        NOT NULL,
+      bucket_id   text        NOT NULL,
+      name        text        NOT NULL,
+      created_at  timestamptz NOT NULL,
+      updated_at  timestamptz NOT NULL,
+      PRIMARY KEY (id)
+    )
+  `);
+}
+//#endregion
+export { bootstrapSupabaseShim };
+
+//# sourceMappingURL=utils.mjs.map

package/dist/test/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../test/supabase-bootstrap.ts"],"sourcesContent":["/**\n * Shared Supabase test fixture — seeds the external schemas and tables.\n *\n * Seeds a Postgres/PGlite database with the external Supabase schemas and\n * tables that the framework verifier expects when a composed contract declares\n * `auth.*` and `storage.*` tables as `external`. Without these tables present,\n * `db init`/`db update` will fail at the verify step because the framework\n * confirms declared `external` tables exist.\n *\n * **M1 scope:** `CREATE SCHEMA auth, storage` + the four tables\n * (`auth.users`, `auth.identities`, `storage.buckets`, `storage.objects`) with\n * columns matching the Supabase extension contract's pinned model table.\n *\n * **Future increments:**\n * - `postgres-rls` constituent adds Postgres roles (`anon`, `authenticated`,\n *   `service_role`) and the `auth.uid()`, `auth.jwt()`, `auth.role()` functions.\n * - `cross-contract-refs` constituent seeds `auth.users` rows for FK tests.\n *\n * The caller owns the client lifecycle — pass any already-connected `pg.Client`\n * (e.g. one the test is sharing across setup steps, or one bound to a\n * transaction for isolation). Convenience wrapper for tests that don't already\n * have one:\n *\n * @example\n * ```ts\n * import { withClient } from '@prisma-next/test-utils';\n * import { bootstrapSupabaseShim } from '@prisma-next/extension-supabase/test/utils';\n *\n * await withClient(connectionString, async (client) => {\n *   await bootstrapSupabaseShim(client);\n * });\n * ```\n */\nimport type { Client } from 'pg';\n\n/**\n * Seeds the database with the external Supabase schemas and tables. The\n * caller passes an already-connected `pg.Client` — this function does not\n * open or close connections, so the same client can be reused across the\n * test's other setup steps.\n *\n * Creates two schemas (`auth`, `storage`) and four tables whose columns\n * exactly match the `@prisma-next/extension-supabase` contract:\n *\n * - `auth.users` — id uuid PK, email text, created_at timestamptz, updated_at timestamptz\n * - `auth.identities` — id uuid PK, user_id uuid, provider text, created_at timestamptz, updated_at timestamptz\n * - `storage.buckets` — id text PK, name text, created_at timestamptz, updated_at timestamptz\n * - `storage.objects` — id uuid PK, bucket_id text, name text, created_at timestamptz, updated_at timestamptz\n *\n * Does NOT create Postgres roles or `auth.*` functions — those are added by\n * the `postgres-rls` constituent.\n */\nexport async function bootstrapSupabaseShim(client: Client): Promise<void> {\n  await client.query('CREATE SCHEMA IF NOT EXISTS auth');\n  await client.query('CREATE SCHEMA IF NOT EXISTS storage');\n\n  await client.query(`\n    CREATE TABLE IF NOT EXISTS auth.users (\n      id          uuid        NOT NULL,\n      email       text        NOT NULL,\n      created_at  timestamptz NOT NULL,\n      updated_at  timestamptz NOT NULL,\n      PRIMARY KEY (id)\n    )\n  `);\n\n  await client.query(`\n    CREATE TABLE IF NOT EXISTS auth.identities (\n      id          uuid        NOT NULL,\n      user_id     uuid        NOT NULL,\n      provider    text        NOT NULL,\n      created_at  timestamptz NOT NULL,\n      updated_at  timestamptz NOT NULL,\n      PRIMARY KEY (id)\n    )\n  `);\n\n  await client.query(`\n    CREATE TABLE IF NOT EXISTS storage.buckets (\n      id          text        NOT NULL,\n      name        text        NOT NULL,\n      created_at  timestamptz NOT NULL,\n      updated_at  timestamptz NOT NULL,\n      PRIMARY KEY (id)\n    )\n  `);\n\n  await client.query(`\n    CREATE TABLE IF NOT EXISTS storage.objects (\n      id          uuid        NOT NULL,\n      bucket_id   text        NOT NULL,\n      name        text        NOT NULL,\n      created_at  timestamptz NOT NULL,\n      updated_at  timestamptz NOT NULL,\n      PRIMARY KEY (id)\n    )\n  `);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoDA,eAAsB,sBAAsB,QAA+B;CACzE,MAAM,OAAO,MAAM,kCAAkC;CACrD,MAAM,OAAO,MAAM,qCAAqC;CAExD,MAAM,OAAO,MAAM;;;;;;;;GAQlB;CAED,MAAM,OAAO,MAAM;;;;;;;;;GASlB;CAED,MAAM,OAAO,MAAM;;;;;;;;GAQlB;CAED,MAAM,OAAO,MAAM;;;;;;;;;GASlB;AACH"}