@prisma-next/extension-supabase 0.12.0

package/src/contract/contract.json

@@ -0,0 +1,483 @@
+{
+  "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"
+  }
+}

package/src/contract/contract.prisma

@@ -0,0 +1,48 @@
+// use prisma-next
+
+types {
+  Uuid        = String   @db.Uuid
+  Timestamptz = DateTime @db.Timestamptz
+}
+
+namespace auth {
+  model AuthUser {
+    id         Uuid        @id
+    email      String
+    created_at Timestamptz
+    updated_at Timestamptz
+
+    @@map("users")
+  }
+
+  model AuthIdentity {
+    id         Uuid        @id
+    user_id    Uuid
+    provider   String
+    created_at Timestamptz
+    updated_at Timestamptz
+
+    @@map("identities")
+  }
+}
+
+namespace storage {
+  model StorageBucket {
+    id         String      @id
+    name       String
+    created_at Timestamptz
+    updated_at Timestamptz
+
+    @@map("buckets")
+  }
+
+  model StorageObject {
+    id         Uuid        @id
+    bucket_id  String
+    name       String
+    created_at Timestamptz
+    updated_at Timestamptz
+
+    @@map("objects")
+  }
+}

package/src/contract/handles.ts

@@ -0,0 +1,78 @@
+/**
+ * Branded model handles for the Supabase contract space.
+ *
+ * Each handle is built via `extensionModel` branded `spaceId: 'supabase'` with
+ * its real domain model name, namespace, table name, and columns — so
+ * `AuthUser.refs.id` is a cross-space `TargetFieldRef` carrying
+ * `spaceId:'supabase'`, `namespaceId:'auth'`, `tableName:'users'`.
+ *
+ * Columns mirror the shipped contract (`src/contract/contract.json`); the
+ * handle↔contract consistency test (`test/contract-handles.test.ts`) asserts
+ * they agree so any drift is caught at test time.
+ */
+import { extensionModel, field } from '@prisma-next/sql-contract-ts/contract-builder';
+
+const pgText = { codecId: 'pg/text@1', nativeType: 'text' } as const;
+const pgTimestamptz = { codecId: 'pg/timestamptz@1', nativeType: 'timestamptz' } as const;
+
+export const AuthUser = extensionModel(
+  'AuthUser',
+  {
+    namespace: 'auth',
+    fields: {
+      id: field.column(pgText).id(),
+      email: field.column(pgText),
+      created_at: field.column(pgTimestamptz),
+      updated_at: field.column(pgTimestamptz),
+    },
+    table: 'users',
+  },
+  'supabase' as const,
+);
+
+export const AuthIdentity = extensionModel(
+  'AuthIdentity',
+  {
+    namespace: 'auth',
+    fields: {
+      id: field.column(pgText).id(),
+      user_id: field.column(pgText),
+      provider: field.column(pgText),
+      created_at: field.column(pgTimestamptz),
+      updated_at: field.column(pgTimestamptz),
+    },
+    table: 'identities',
+  },
+  'supabase' as const,
+);
+
+export const StorageBucket = extensionModel(
+  'StorageBucket',
+  {
+    namespace: 'storage',
+    fields: {
+      id: field.column(pgText).id(),
+      name: field.column(pgText),
+      created_at: field.column(pgTimestamptz),
+      updated_at: field.column(pgTimestamptz),
+    },
+    table: 'buckets',
+  },
+  'supabase' as const,
+);
+
+export const StorageObject = extensionModel(
+  'StorageObject',
+  {
+    namespace: 'storage',
+    fields: {
+      id: field.column(pgText).id(),
+      bucket_id: field.column(pgText),
+      name: field.column(pgText),
+      created_at: field.column(pgTimestamptz),
+      updated_at: field.column(pgTimestamptz),
+    },
+    table: 'objects',
+  },
+  'supabase' as const,
+);

package/src/exports/contract.ts

@@ -0,0 +1 @@
+export { AuthIdentity, AuthUser, StorageBucket, StorageObject } from '../contract/handles';

package/src/exports/pack.ts

@@ -0,0 +1 @@
+export { default, supabasePackWith } from '../pack/index';

package/src/exports/runtime.ts

@@ -0,0 +1,31 @@
+/**
+ * Minimal M1 runtime descriptor for the Supabase extension.
+ *
+ * The Supabase pack contributes no runtime codec types or query operations in
+ * M1 — `auth.*`/`storage.*` are external tables accessed via the stock
+ * postgres runtime, not through a custom codec or operation surface. This
+ * descriptor exists so the postgres runtime's contract-requirements check
+ * (which verifies every `extensionPacks` entry in the emitted `contract.json`
+ * has a matching runtime component) passes.
+ *
+ * TODO(M2): Replace with the real SupabaseRuntime that adds
+ *   `asUser()`/`asAnon()` role-binding and the Supabase auth surface.
+ */
+import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';
+
+const supabaseRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
+  kind: 'extension' as const,
+  id: 'supabase',
+  version: '0.12.0',
+  familyId: 'sql' as const,
+  targetId: 'postgres' as const,
+  codecs: () => [],
+  create() {
+    return {
+      familyId: 'sql' as const,
+      targetId: 'postgres' as const,
+    };
+  },
+};
+
+export default supabaseRuntimeDescriptor;

package/src/pack/index.ts

@@ -0,0 +1,55 @@
+import type { SqlControlExtensionDescriptor } from '@prisma-next/family-sql/control';
+import { blindCast } from '@prisma-next/utils/casts';
+import packageJson from '../../package.json' with { type: 'json' };
+import type { Contract } from '../contract/contract.d';
+import contractJson from '../contract/contract.json' with { type: 'json' };
+
+const SUPABASE_SPACE_ID = 'supabase' as const;
+
+function buildContractSpace(contractOverride?: unknown) {
+  const contract = blindCast<
+    Contract,
+    'JSON import narrowed to emitted Contract type; assertDescriptorSelfConsistency verifies the storageHash at load time'
+  >(contractOverride ?? contractJson);
+  return {
+    contractJson: contract,
+    migrations: [] as const,
+    headRef: { hash: contract.storage.storageHash, invariants: [] as const },
+  };
+}
+
+const supabaseContractSpace = buildContractSpace();
+
+const supabasePackBase = {
+  kind: 'extension' as const,
+  id: SUPABASE_SPACE_ID,
+  familyId: 'sql' as const,
+  targetId: 'postgres' as const,
+  version: packageJson.version,
+  contractSpace: supabaseContractSpace,
+  create: () => ({
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+  }),
+} satisfies SqlControlExtensionDescriptor<'postgres'>;
+
+export const supabasePack: SqlControlExtensionDescriptor<'postgres'> = 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.
+ */
+export function supabasePackWith(options?: {
+  contractOverride?: unknown;
+}): SqlControlExtensionDescriptor<'postgres'> {
+  if (options?.contractOverride === undefined) return supabasePack;
+  return {
+    ...supabasePackBase,
+    contractSpace: buildContractSpace(options.contractOverride),
+  };
+}
+
+export default supabasePack;