+96 -96

drizzle/relations.ts

··· 1 1 import { relations } from "drizzle-orm/relations"; 2 2 - import { identities, bsky_profiles, publications, documents, comments_on_documents, entities, facts, entity_sets, permission_tokens, email_subscriptions_to_entity, email_auth_tokens, custom_domains, phone_rsvps_to_entity, custom_domain_routes, poll_votes_on_entity, bsky_follows, subscribers_to_publications, document_mentions_in_bsky, bsky_posts, permission_token_on_homepage, documents_in_publications, publication_domains, publication_subscriptions, leaflets_in_publications, permission_token_rights } from "./schema"; 2 2 + import { identities, publications, documents, comments_on_documents, bsky_profiles, entity_sets, entities, facts, email_auth_tokens, poll_votes_on_entity, permission_tokens, phone_rsvps_to_entity, custom_domains, custom_domain_routes, email_subscriptions_to_entity, bsky_follows, subscribers_to_publications, permission_token_on_homepage, documents_in_publications, document_mentions_in_bsky, bsky_posts, publication_domains, leaflets_in_publications, publication_subscriptions, permission_token_rights } from "./schema"; 3 3 4 4 - export const bsky_profilesRelations = relations(bsky_profiles, ({one, many}) => ({ 4 4 + export const publicationsRelations = relations(publications, ({one, many}) => ({ 5 5 identity: one(identities, { 6 6 - fields: [bsky_profiles.did], 6 6 + fields: [publications.identity_did], 7 7 references: [identities.atp_did] 8 8 }), 9 9 - comments_on_documents: many(comments_on_documents), 9 9 + subscribers_to_publications: many(subscribers_to_publications), 10 10 + documents_in_publications: many(documents_in_publications), 11 11 + publication_domains: many(publication_domains), 12 12 + leaflets_in_publications: many(leaflets_in_publications), 13 13 + publication_subscriptions: many(publication_subscriptions), 10 14 })); 11 15 12 16 export const identitiesRelations = relations(identities, ({one, many}) => ({ 17 17 + publications: many(publications), 18 18 + email_auth_tokens: many(email_auth_tokens), 13 19 bsky_profiles: many(bsky_profiles), 14 14 - publications: many(publications), 15 20 permission_token: one(permission_tokens, { 16 21 fields: [identities.home_page], 17 22 references: [permission_tokens.id] 18 23 }), 19 19 - email_auth_tokens: many(email_auth_tokens), 20 24 custom_domains_identity: many(custom_domains, { 21 25 relationName: "custom_domains_identity_identities_email" 22 26 }), ··· 35 39 publication_subscriptions: many(publication_subscriptions), 36 40 })); 37 41 38 38 - export const publicationsRelations = relations(publications, ({one, many}) => ({ 39 39 - identity: one(identities, { 40 40 - fields: [publications.identity_did], 41 41 - references: [identities.atp_did] 42 42 - }), 43 43 - subscribers_to_publications: many(subscribers_to_publications), 44 44 - documents_in_publications: many(documents_in_publications), 45 45 - publication_domains: many(publication_domains), 46 46 - publication_subscriptions: many(publication_subscriptions), 47 47 - leaflets_in_publications: many(leaflets_in_publications), 48 48 - })); 49 49 - 50 42 export const comments_on_documentsRelations = relations(comments_on_documents, ({one}) => ({ 51 43 document: one(documents, { 52 44 fields: [comments_on_documents.document], ··· 60 52 61 53 export const documentsRelations = relations(documents, ({many}) => ({ 62 54 comments_on_documents: many(comments_on_documents), 63 63 - document_mentions_in_bskies: many(document_mentions_in_bsky), 64 55 documents_in_publications: many(documents_in_publications), 56 56 + document_mentions_in_bskies: many(document_mentions_in_bsky), 65 57 leaflets_in_publications: many(leaflets_in_publications), 66 58 })); 67 59 68 68 - export const factsRelations = relations(facts, ({one}) => ({ 69 69 - entity: one(entities, { 70 70 - fields: [facts.entity], 71 71 - references: [entities.id] 60 60 + export const bsky_profilesRelations = relations(bsky_profiles, ({one, many}) => ({ 61 61 + comments_on_documents: many(comments_on_documents), 62 62 + identity: one(identities, { 63 63 + fields: [bsky_profiles.did], 64 64 + references: [identities.atp_did] 72 65 }), 73 66 })); 74 67 75 68 export const entitiesRelations = relations(entities, ({one, many}) => ({ 76 76 - facts: many(facts), 77 69 entity_set: one(entity_sets, { 78 70 fields: [entities.set], 79 71 references: [entity_sets.id] 80 72 }), 81 81 - permission_tokens: many(permission_tokens), 82 82 - email_subscriptions_to_entities: many(email_subscriptions_to_entity), 83 83 - phone_rsvps_to_entities: many(phone_rsvps_to_entity), 73 73 + facts: many(facts), 84 74 poll_votes_on_entities_option_entity: many(poll_votes_on_entity, { 85 75 relationName: "poll_votes_on_entity_option_entity_entities_id" 86 76 }), 87 77 poll_votes_on_entities_poll_entity: many(poll_votes_on_entity, { 88 78 relationName: "poll_votes_on_entity_poll_entity_entities_id" 89 79 }), 80 80 + permission_tokens: many(permission_tokens), 81 81 + phone_rsvps_to_entities: many(phone_rsvps_to_entity), 82 82 + email_subscriptions_to_entities: many(email_subscriptions_to_entity), 90 83 })); 91 84 92 85 export const entity_setsRelations = relations(entity_sets, ({many}) => ({ ··· 94 87 permission_token_rights: many(permission_token_rights), 95 88 })); 96 89 90 90 + export const factsRelations = relations(facts, ({one}) => ({ 91 91 + entity: one(entities, { 92 92 + fields: [facts.entity], 93 93 + references: [entities.id] 94 94 + }), 95 95 + })); 96 96 + 97 97 + export const email_auth_tokensRelations = relations(email_auth_tokens, ({one}) => ({ 98 98 + identity: one(identities, { 99 99 + fields: [email_auth_tokens.identity], 100 100 + references: [identities.id] 101 101 + }), 102 102 + })); 103 103 + 104 104 + export const poll_votes_on_entityRelations = relations(poll_votes_on_entity, ({one}) => ({ 105 105 + entity_option_entity: one(entities, { 106 106 + fields: [poll_votes_on_entity.option_entity], 107 107 + references: [entities.id], 108 108 + relationName: "poll_votes_on_entity_option_entity_entities_id" 109 109 + }), 110 110 + entity_poll_entity: one(entities, { 111 111 + fields: [poll_votes_on_entity.poll_entity], 112 112 + references: [entities.id], 113 113 + relationName: "poll_votes_on_entity_poll_entity_entities_id" 114 114 + }), 115 115 + })); 116 116 + 97 117 export const permission_tokensRelations = relations(permission_tokens, ({one, many}) => ({ 98 118 entity: one(entities, { 99 119 fields: [permission_tokens.root_entity], 100 120 references: [entities.id] 101 121 }), 102 122 identities: many(identities), 103 103 - email_subscriptions_to_entities: many(email_subscriptions_to_entity), 104 123 custom_domain_routes_edit_permission_token: many(custom_domain_routes, { 105 124 relationName: "custom_domain_routes_edit_permission_token_permission_tokens_id" 106 125 }), 107 126 custom_domain_routes_view_permission_token: many(custom_domain_routes, { 108 127 relationName: "custom_domain_routes_view_permission_token_permission_tokens_id" 109 128 }), 129 129 + email_subscriptions_to_entities: many(email_subscriptions_to_entity), 110 130 permission_token_on_homepages: many(permission_token_on_homepage), 111 131 leaflets_in_publications: many(leaflets_in_publications), 112 132 permission_token_rights: many(permission_token_rights), 113 133 })); 114 134 115 115 - export const email_subscriptions_to_entityRelations = relations(email_subscriptions_to_entity, ({one}) => ({ 116 116 - entity: one(entities, { 117 117 - fields: [email_subscriptions_to_entity.entity], 118 118 - references: [entities.id] 119 119 - }), 120 120 - permission_token: one(permission_tokens, { 121 121 - fields: [email_subscriptions_to_entity.token], 122 122 - references: [permission_tokens.id] 123 123 - }), 124 124 - })); 125 125 - 126 126 - export const email_auth_tokensRelations = relations(email_auth_tokens, ({one}) => ({ 127 127 - identity: one(identities, { 128 128 - fields: [email_auth_tokens.identity], 129 129 - references: [identities.id] 130 130 - }), 131 131 - })); 132 132 - 133 133 - export const custom_domainsRelations = relations(custom_domains, ({one, many}) => ({ 134 134 - identity_identity: one(identities, { 135 135 - fields: [custom_domains.identity], 136 136 - references: [identities.email], 137 137 - relationName: "custom_domains_identity_identities_email" 138 138 - }), 139 139 - identity_identity_id: one(identities, { 140 140 - fields: [custom_domains.identity_id], 141 141 - references: [identities.id], 142 142 - relationName: "custom_domains_identity_id_identities_id" 143 143 - }), 144 144 - custom_domain_routes: many(custom_domain_routes), 145 145 - publication_domains: many(publication_domains), 146 146 - })); 147 147 - 148 135 export const phone_rsvps_to_entityRelations = relations(phone_rsvps_to_entity, ({one}) => ({ 149 136 entity: one(entities, { 150 137 fields: [phone_rsvps_to_entity.entity], ··· 169 156 }), 170 157 })); 171 158 172 172 - export const poll_votes_on_entityRelations = relations(poll_votes_on_entity, ({one}) => ({ 173 173 - entity_option_entity: one(entities, { 174 174 - fields: [poll_votes_on_entity.option_entity], 175 175 - references: [entities.id], 176 176 - relationName: "poll_votes_on_entity_option_entity_entities_id" 159 159 + export const custom_domainsRelations = relations(custom_domains, ({one, many}) => ({ 160 160 + custom_domain_routes: many(custom_domain_routes), 161 161 + identity_identity: one(identities, { 162 162 + fields: [custom_domains.identity], 163 163 + references: [identities.email], 164 164 + relationName: "custom_domains_identity_identities_email" 177 165 }), 178 178 - entity_poll_entity: one(entities, { 179 179 - fields: [poll_votes_on_entity.poll_entity], 180 180 - references: [entities.id], 181 181 - relationName: "poll_votes_on_entity_poll_entity_entities_id" 166 166 + identity_identity_id: one(identities, { 167 167 + fields: [custom_domains.identity_id], 168 168 + references: [identities.id], 169 169 + relationName: "custom_domains_identity_id_identities_id" 170 170 + }), 171 171 + publication_domains: many(publication_domains), 172 172 + })); 173 173 + 174 174 + export const email_subscriptions_to_entityRelations = relations(email_subscriptions_to_entity, ({one}) => ({ 175 175 + entity: one(entities, { 176 176 + fields: [email_subscriptions_to_entity.entity], 177 177 + references: [entities.id] 178 178 + }), 179 179 + permission_token: one(permission_tokens, { 180 180 + fields: [email_subscriptions_to_entity.token], 181 181 + references: [permission_tokens.id] 182 182 }), 183 183 })); 184 184 ··· 206 206 }), 207 207 })); 208 208 209 209 - export const document_mentions_in_bskyRelations = relations(document_mentions_in_bsky, ({one}) => ({ 210 210 - document: one(documents, { 211 211 - fields: [document_mentions_in_bsky.document], 212 212 - references: [documents.uri] 213 213 - }), 214 214 - bsky_post: one(bsky_posts, { 215 215 - fields: [document_mentions_in_bsky.uri], 216 216 - references: [bsky_posts.uri] 217 217 - }), 218 218 - })); 219 219 - 220 220 - export const bsky_postsRelations = relations(bsky_posts, ({many}) => ({ 221 221 - document_mentions_in_bskies: many(document_mentions_in_bsky), 222 222 - })); 223 223 - 224 209 export const permission_token_on_homepageRelations = relations(permission_token_on_homepage, ({one}) => ({ 225 210 identity: one(identities, { 226 211 fields: [permission_token_on_homepage.identity], ··· 243 228 }), 244 229 })); 245 230 231 231 + export const document_mentions_in_bskyRelations = relations(document_mentions_in_bsky, ({one}) => ({ 232 232 + document: one(documents, { 233 233 + fields: [document_mentions_in_bsky.document], 234 234 + references: [documents.uri] 235 235 + }), 236 236 + bsky_post: one(bsky_posts, { 237 237 + fields: [document_mentions_in_bsky.uri], 238 238 + references: [bsky_posts.uri] 239 239 + }), 240 240 + })); 241 241 + 242 242 + export const bsky_postsRelations = relations(bsky_posts, ({many}) => ({ 243 243 + document_mentions_in_bskies: many(document_mentions_in_bsky), 244 244 + })); 245 245 + 246 246 export const publication_domainsRelations = relations(publication_domains, ({one}) => ({ 247 247 custom_domain: one(custom_domains, { 248 248 fields: [publication_domains.domain], ··· 258 258 }), 259 259 })); 260 260 261 261 - export const publication_subscriptionsRelations = relations(publication_subscriptions, ({one}) => ({ 262 262 - identity: one(identities, { 263 263 - fields: [publication_subscriptions.identity], 264 264 - references: [identities.atp_did] 265 265 - }), 266 266 - publication: one(publications, { 267 267 - fields: [publication_subscriptions.publication], 268 268 - references: [publications.uri] 269 269 - }), 270 270 - })); 271 271 - 272 261 export const leaflets_in_publicationsRelations = relations(leaflets_in_publications, ({one}) => ({ 273 262 document: one(documents, { 274 263 fields: [leaflets_in_publications.doc], ··· 280 269 }), 281 270 publication: one(publications, { 282 271 fields: [leaflets_in_publications.publication], 272 272 + references: [publications.uri] 273 273 + }), 274 274 + })); 275 275 + 276 276 + export const publication_subscriptionsRelations = relations(publication_subscriptions, ({one}) => ({ 277 277 + identity: one(identities, { 278 278 + fields: [publication_subscriptions.identity], 279 279 + references: [identities.atp_did] 280 280 + }), 281 281 + publication: one(publications, { 282 282 + fields: [publication_subscriptions.publication], 283 283 references: [publications.uri] 284 284 }), 285 285 }));

+119 -86

drizzle/schema.ts

··· 1 1 - import { pgTable, pgEnum, text, jsonb, foreignKey, timestamp, uuid, bigint, boolean, unique, uniqueIndex, smallint, primaryKey } from "drizzle-orm/pg-core" 1 1 + import { pgTable, pgEnum, text, jsonb, index, foreignKey, timestamp, uuid, bigint, boolean, unique, uniqueIndex, smallint, primaryKey } from "drizzle-orm/pg-core" 2 2 import { sql } from "drizzle-orm" 3 3 4 4 export const aal_level = pgEnum("aal_level", ['aal1', 'aal2', 'aal3']) 5 5 export const code_challenge_method = pgEnum("code_challenge_method", ['s256', 'plain']) 6 6 export const factor_status = pgEnum("factor_status", ['unverified', 'verified']) 7 7 - export const factor_type = pgEnum("factor_type", ['totp', 'webauthn']) 7 7 + export const factor_type = pgEnum("factor_type", ['totp', 'webauthn', 'phone']) 8 8 + export const oauth_authorization_status = pgEnum("oauth_authorization_status", ['pending', 'approved', 'denied', 'expired']) 9 9 + export const oauth_client_type = pgEnum("oauth_client_type", ['public', 'confidential']) 10 10 + export const oauth_registration_type = pgEnum("oauth_registration_type", ['dynamic', 'manual']) 11 11 + export const oauth_response_type = pgEnum("oauth_response_type", ['code']) 8 12 export const one_time_token_type = pgEnum("one_time_token_type", ['confirmation_token', 'reauthentication_token', 'recovery_token', 'email_change_token_new', 'email_change_token_current', 'phone_change_token']) 9 9 - export const request_status = pgEnum("request_status", ['PENDING', 'SUCCESS', 'ERROR']) 10 13 export const key_status = pgEnum("key_status", ['default', 'valid', 'invalid', 'expired']) 11 14 export const key_type = pgEnum("key_type", ['aead-ietf', 'aead-det', 'hmacsha512', 'hmacsha256', 'auth', 'shorthash', 'generichash', 'kdf', 'secretbox', 'secretstream', 'stream_xchacha20']) 12 15 export const rsvp_status = pgEnum("rsvp_status", ['GOING', 'NOT_GOING', 'MAYBE']) 13 16 export const action = pgEnum("action", ['INSERT', 'UPDATE', 'DELETE', 'TRUNCATE', 'ERROR']) 14 17 export const equality_op = pgEnum("equality_op", ['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in']) 18 18 + export const buckettype = pgEnum("buckettype", ['STANDARD', 'ANALYTICS']) 15 19 16 20 17 21 export const oauth_state_store = pgTable("oauth_state_store", { ··· 19 23 state: jsonb("state").notNull(), 20 24 }); 21 25 22 22 - export const oauth_session_store = pgTable("oauth_session_store", { 23 23 - key: text("key").primaryKey().notNull(), 24 24 - session: jsonb("session").notNull(), 25 25 - }); 26 26 - 27 27 - export const bsky_profiles = pgTable("bsky_profiles", { 28 28 - did: text("did").primaryKey().notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 29 29 - record: jsonb("record").notNull(), 30 30 - indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 31 31 - handle: text("handle"), 32 32 - }); 33 33 - 34 26 export const publications = pgTable("publications", { 35 27 uri: text("uri").primaryKey().notNull(), 36 28 indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 37 29 name: text("name").notNull(), 38 30 identity_did: text("identity_did").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 39 31 record: jsonb("record"), 40 40 - }); 41 41 - 42 42 - export const bsky_posts = pgTable("bsky_posts", { 43 43 - uri: text("uri").primaryKey().notNull(), 44 44 - indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 45 45 - post_view: jsonb("post_view").notNull(), 46 46 - cid: text("cid").notNull(), 32 32 + }, 33 33 + (table) => { 34 34 + return { 35 35 + identity_did_idx: index("publications_identity_did_idx").on(table.identity_did), 36 36 + } 47 37 }); 48 38 49 39 export const comments_on_documents = pgTable("comments_on_documents", { ··· 54 44 profile: text("profile").references(() => bsky_profiles.did, { onDelete: "set null", onUpdate: "cascade" } ), 55 45 }); 56 46 47 47 + export const entities = pgTable("entities", { 48 48 + id: uuid("id").primaryKey().notNull(), 49 49 + created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 50 50 + set: uuid("set").notNull().references(() => entity_sets.id, { onDelete: "cascade", onUpdate: "cascade" } ), 51 51 + }, 52 52 + (table) => { 53 53 + return { 54 54 + set_idx: index("entities_set_idx").on(table.set), 55 55 + } 56 56 + }); 57 57 + 57 58 export const facts = pgTable("facts", { 58 59 id: uuid("id").primaryKey().notNull(), 59 60 entity: uuid("entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "restrict" } ), ··· 63 64 updated_at: timestamp("updated_at", { mode: 'string' }), 64 65 // You can use { mode: "bigint" } if numbers are exceeding js number limitations 65 66 version: bigint("version", { mode: "number" }).default(0).notNull(), 66 66 - }); 67 67 - 68 68 - export const documents = pgTable("documents", { 69 69 - uri: text("uri").primaryKey().notNull(), 70 70 - data: jsonb("data").notNull(), 71 71 - indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 67 67 + }, 68 68 + (table) => { 69 69 + return { 70 70 + entity_idx: index("facts_entity_idx").on(table.entity), 71 71 + } 72 72 }); 73 73 74 74 export const replicache_clients = pgTable("replicache_clients", { ··· 76 76 client_group: text("client_group").notNull(), 77 77 // You can use { mode: "bigint" } if numbers are exceeding js number limitations 78 78 last_mutation: bigint("last_mutation", { mode: "number" }).notNull(), 79 79 + }, 80 80 + (table) => { 81 81 + return { 82 82 + client_group_idx: index("replicache_clients_client_group_idx").on(table.client_group), 83 83 + } 79 84 }); 80 85 81 81 - export const entities = pgTable("entities", { 82 82 - id: uuid("id").primaryKey().notNull(), 86 86 + export const email_auth_tokens = pgTable("email_auth_tokens", { 87 87 + id: uuid("id").defaultRandom().primaryKey().notNull(), 83 88 created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 84 84 - set: uuid("set").notNull().references(() => entity_sets.id, { onDelete: "cascade", onUpdate: "cascade" } ), 89 89 + confirmed: boolean("confirmed").default(false).notNull(), 90 90 + email: text("email"), 91 91 + confirmation_code: text("confirmation_code").notNull(), 92 92 + identity: uuid("identity").references(() => identities.id, { onDelete: "cascade", onUpdate: "cascade" } ), 93 93 + }); 94 94 + 95 95 + export const bsky_posts = pgTable("bsky_posts", { 96 96 + uri: text("uri").primaryKey().notNull(), 97 97 + indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 98 98 + post_view: jsonb("post_view").notNull(), 99 99 + cid: text("cid").notNull(), 100 100 + }); 101 101 + 102 102 + export const bsky_profiles = pgTable("bsky_profiles", { 103 103 + did: text("did").primaryKey().notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 104 104 + record: jsonb("record").notNull(), 105 105 + indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 106 106 + handle: text("handle"), 85 107 }); 86 108 87 109 export const entity_sets = pgTable("entity_sets", { 88 110 id: uuid("id").defaultRandom().primaryKey().notNull(), 89 111 created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 112 112 + }); 113 113 + 114 114 + export const poll_votes_on_entity = pgTable("poll_votes_on_entity", { 115 115 + id: uuid("id").defaultRandom().primaryKey().notNull(), 116 116 + created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 117 117 + poll_entity: uuid("poll_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ), 118 118 + option_entity: uuid("option_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ), 119 119 + voter_token: uuid("voter_token").notNull(), 90 120 }); 91 121 92 122 export const permission_tokens = pgTable("permission_tokens", { ··· 110 140 } 111 141 }); 112 142 113 113 - export const email_subscriptions_to_entity = pgTable("email_subscriptions_to_entity", { 114 114 - id: uuid("id").defaultRandom().primaryKey().notNull(), 115 115 - entity: uuid("entity").notNull().references(() => entities.id, { onDelete: "cascade" } ), 116 116 - email: text("email").notNull(), 117 117 - created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 118 118 - token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade" } ), 119 119 - confirmed: boolean("confirmed").default(false).notNull(), 120 120 - confirmation_code: text("confirmation_code").notNull(), 121 121 - }); 122 122 - 123 123 - export const email_auth_tokens = pgTable("email_auth_tokens", { 124 124 - id: uuid("id").defaultRandom().primaryKey().notNull(), 125 125 - created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 126 126 - confirmed: boolean("confirmed").default(false).notNull(), 127 127 - email: text("email"), 128 128 - confirmation_code: text("confirmation_code").notNull(), 129 129 - identity: uuid("identity").references(() => identities.id, { onDelete: "cascade", onUpdate: "cascade" } ), 130 130 - }); 131 131 - 132 143 export const phone_number_auth_tokens = pgTable("phone_number_auth_tokens", { 133 144 id: uuid("id").defaultRandom().primaryKey().notNull(), 134 145 created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), ··· 136 147 confirmation_code: text("confirmation_code").notNull(), 137 148 phone_number: text("phone_number").notNull(), 138 149 country_code: text("country_code").notNull(), 139 139 - }); 140 140 - 141 141 - export const custom_domains = pgTable("custom_domains", { 142 142 - domain: text("domain").primaryKey().notNull(), 143 143 - identity: text("identity").default('').references(() => identities.email, { onDelete: "cascade", onUpdate: "cascade" } ), 144 144 - confirmed: boolean("confirmed").notNull(), 145 145 - created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 146 146 - identity_id: uuid("identity_id").references(() => identities.id, { onDelete: "cascade" } ), 147 150 }); 148 151 149 152 export const phone_rsvps_to_entity = pgTable("phone_rsvps_to_entity", { ··· 172 175 }, 173 176 (table) => { 174 177 return { 178 178 + edit_permission_token_idx: index("custom_domain_routes_edit_permission_token_idx").on(table.edit_permission_token), 175 179 custom_domain_routes_domain_route_key: unique("custom_domain_routes_domain_route_key").on(table.domain, table.route), 176 180 } 177 181 }); 178 182 179 179 - export const poll_votes_on_entity = pgTable("poll_votes_on_entity", { 183 183 + export const custom_domains = pgTable("custom_domains", { 184 184 + domain: text("domain").primaryKey().notNull(), 185 185 + identity: text("identity").default('').references(() => identities.email, { onDelete: "cascade", onUpdate: "cascade" } ), 186 186 + confirmed: boolean("confirmed").notNull(), 187 187 + created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 188 188 + identity_id: uuid("identity_id").references(() => identities.id, { onDelete: "cascade" } ), 189 189 + }); 190 190 + 191 191 + export const email_subscriptions_to_entity = pgTable("email_subscriptions_to_entity", { 180 192 id: uuid("id").defaultRandom().primaryKey().notNull(), 193 193 + entity: uuid("entity").notNull().references(() => entities.id, { onDelete: "cascade" } ), 194 194 + email: text("email").notNull(), 181 195 created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 182 182 - poll_entity: uuid("poll_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ), 183 183 - option_entity: uuid("option_entity").notNull().references(() => entities.id, { onDelete: "cascade", onUpdate: "cascade" } ), 184 184 - voter_token: uuid("voter_token").notNull(), 196 196 + token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade" } ), 197 197 + confirmed: boolean("confirmed").default(false).notNull(), 198 198 + confirmation_code: text("confirmation_code").notNull(), 199 199 + }); 200 200 + 201 201 + export const documents = pgTable("documents", { 202 202 + uri: text("uri").primaryKey().notNull(), 203 203 + data: jsonb("data").notNull(), 204 204 + indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 205 205 + }); 206 206 + 207 207 + export const oauth_session_store = pgTable("oauth_session_store", { 208 208 + key: text("key").primaryKey().notNull(), 209 209 + session: jsonb("session").notNull(), 185 210 }); 186 211 187 212 export const bsky_follows = pgTable("bsky_follows", { 188 188 - identity: text("identity").default('').notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 213 213 + identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 189 214 follows: text("follows").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 190 215 }, 191 216 (table) => { ··· 205 230 } 206 231 }); 207 232 208 208 - export const document_mentions_in_bsky = pgTable("document_mentions_in_bsky", { 209 209 - uri: text("uri").notNull().references(() => bsky_posts.uri, { onDelete: "cascade" } ), 210 210 - link: text("link").notNull(), 211 211 - document: text("document").notNull().references(() => documents.uri, { onDelete: "cascade" } ), 212 212 - }, 213 213 - (table) => { 214 214 - return { 215 215 - document_mentions_in_bsky_pkey: primaryKey({ columns: [table.uri, table.document], name: "document_mentions_in_bsky_pkey"}), 216 216 - } 217 217 - }); 218 218 - 219 233 export const permission_token_on_homepage = pgTable("permission_token_on_homepage", { 220 234 token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade" } ), 221 235 identity: uuid("identity").notNull().references(() => identities.id, { onDelete: "cascade" } ), ··· 234 248 }, 235 249 (table) => { 236 250 return { 251 251 + publication_idx: index("documents_in_publications_publication_idx").on(table.publication), 237 252 documents_in_publications_pkey: primaryKey({ columns: [table.publication, table.document], name: "documents_in_publications_pkey"}), 238 253 } 239 254 }); 240 255 241 241 - export const publication_domains = pgTable("publication_domains", { 242 242 - publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ), 243 243 - domain: text("domain").notNull().references(() => custom_domains.domain, { onDelete: "cascade" } ), 244 244 - created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 245 245 - identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade", onUpdate: "cascade" } ), 256 256 + export const document_mentions_in_bsky = pgTable("document_mentions_in_bsky", { 257 257 + uri: text("uri").notNull().references(() => bsky_posts.uri, { onDelete: "cascade" } ), 258 258 + link: text("link").notNull(), 259 259 + document: text("document").notNull().references(() => documents.uri, { onDelete: "cascade" } ), 260 260 + indexed_at: timestamp("indexed_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 246 261 }, 247 262 (table) => { 248 263 return { 249 249 - publication_domains_pkey: primaryKey({ columns: [table.publication, table.domain], name: "publication_domains_pkey"}), 264 264 + document_mentions_in_bsky_pkey: primaryKey({ columns: [table.uri, table.document], name: "document_mentions_in_bsky_pkey"}), 250 265 } 251 266 }); 252 267 253 253 - export const publication_subscriptions = pgTable("publication_subscriptions", { 268 268 + export const publication_domains = pgTable("publication_domains", { 254 269 publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ), 255 255 - identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 270 270 + domain: text("domain").notNull().references(() => custom_domains.domain, { onDelete: "cascade" } ), 256 271 created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 257 257 - record: jsonb("record").notNull(), 258 258 - uri: text("uri").notNull(), 272 272 + identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade", onUpdate: "cascade" } ), 259 273 }, 260 274 (table) => { 261 275 return { 262 262 - publication_subscriptions_pkey: primaryKey({ columns: [table.publication, table.identity], name: "publication_subscriptions_pkey"}), 263 263 - publication_subscriptions_uri_key: unique("publication_subscriptions_uri_key").on(table.uri), 276 276 + publication_idx: index("publication_domains_publication_idx").on(table.publication), 277 277 + publication_domains_pkey: primaryKey({ columns: [table.publication, table.domain], name: "publication_domains_pkey"}), 264 278 } 265 279 }); 266 280 ··· 273 287 }, 274 288 (table) => { 275 289 return { 290 290 + leaflet_idx: index("leaflets_in_publications_leaflet_idx").on(table.leaflet), 291 291 + publication_idx: index("leaflets_in_publications_publication_idx").on(table.publication), 276 292 leaflets_in_publications_pkey: primaryKey({ columns: [table.publication, table.leaflet], name: "leaflets_in_publications_pkey"}), 277 293 } 278 294 }); 279 295 296 296 + export const publication_subscriptions = pgTable("publication_subscriptions", { 297 297 + publication: text("publication").notNull().references(() => publications.uri, { onDelete: "cascade" } ), 298 298 + identity: text("identity").notNull().references(() => identities.atp_did, { onDelete: "cascade" } ), 299 299 + created_at: timestamp("created_at", { withTimezone: true, mode: 'string' }).defaultNow().notNull(), 300 300 + record: jsonb("record").notNull(), 301 301 + uri: text("uri").notNull(), 302 302 + }, 303 303 + (table) => { 304 304 + return { 305 305 + publication_idx: index("publication_subscriptions_publication_idx").on(table.publication), 306 306 + publication_subscriptions_pkey: primaryKey({ columns: [table.publication, table.identity], name: "publication_subscriptions_pkey"}), 307 307 + publication_subscriptions_uri_key: unique("publication_subscriptions_uri_key").on(table.uri), 308 308 + } 309 309 + }); 310 310 + 280 311 export const permission_token_rights = pgTable("permission_token_rights", { 281 312 token: uuid("token").notNull().references(() => permission_tokens.id, { onDelete: "cascade", onUpdate: "cascade" } ), 282 313 entity_set: uuid("entity_set").notNull().references(() => entity_sets.id, { onDelete: "cascade", onUpdate: "cascade" } ), ··· 288 319 }, 289 320 (table) => { 290 321 return { 322 322 + token_idx: index("permission_token_rights_token_idx").on(table.token), 323 323 + entity_set_idx: index("permission_token_rights_entity_set_idx").on(table.entity_set), 291 324 permission_token_rights_pkey: primaryKey({ columns: [table.token, table.entity_set], name: "permission_token_rights_pkey"}), 292 325 } 293 326 });

+3

supabase/database.types.ts

··· 244 244 document_mentions_in_bsky: { 245 245 Row: { 246 246 document: string 247 247 + indexed_at: string 247 248 link: string 248 249 uri: string 249 250 } 250 251 Insert: { 251 252 document: string 253 253 + indexed_at?: string 252 254 link: string 253 255 uri: string 254 256 } 255 257 Update: { 256 258 document?: string 259 259 + indexed_at?: string 257 260 link?: string 258 261 uri?: string 259 262 }

+1

supabase/migrations/20251017160632_add_indexed_at_to_document_mentions_in_bsky.sql

··· 1 1 + alter table "public"."document_mentions_in_bsky" add column "indexed_at" timestamp with time zone not null default now();