@coffre/db 0.0.0 → 0.1.0

package/dist/migrations/sqlite/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1790874462505,
+      "tag": "0000_baseline",
+      "breakpoints": true
+    }
+  ]
+}

package/dist/portable.d.ts

@@ -0,0 +1,33 @@
+import { l as schema_d_exports } from "./schema-Cd4WOnB5.js";
+import { t as Database } from "./database-CWpo5aF0.js";
+import { t as schema_sqlite_d_exports } from "./schema-sqlite.js";
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+//#region src/portable.d.ts
+/**
+ * The one place a SQLite database becomes a Postgres one.
+ *
+ * Drizzle has no type that spans dialects, so the queries are written once,
+ * against the Postgres schema, and a SQLite database is handed to
+ * them under the Postgres type. That holds because both schemas have the
+ * same tables with the same row types (checked below, at compile time, and
+ * in schema-parity.test.ts, at run time), and because every query runs on
+ * the database's own tables: queries.ts reads them from the database it is
+ * given (`tablesOf`), never from an import. A Postgres column on a SQLite
+ * database would encode its values the Postgres way.
+ */
+export type PostgresSchema = typeof schema_d_exports;
+/** Some of a schema's tables, read as their Postgres twins. */
+export declare function asPostgres<Tables extends Partial<Record<keyof PostgresSchema, unknown>>>(tables: Tables): Pick<PostgresSchema, keyof Tables & keyof PostgresSchema>;
+/** A SQLite database, read as a Postgres one. */
+export declare function asPostgresDatabase(db: LibSQLDatabase<typeof schema_sqlite_d_exports>): Database;
+type TableName = { [K in keyof PostgresSchema]: PostgresSchema[K] extends {
+  $inferSelect: object;
+} ? K : never; }[keyof PostgresSchema];
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/** The tables whose rows differ from their Postgres twin's; never if none. */
+type Mismatched<Schema extends Record<TableName, {
+  $inferSelect: object;
+}>> = { [K in TableName]: Equal<Schema[K]['$inferSelect'], PostgresSchema[K]['$inferSelect']> extends true ? never : K; }[TableName];
+type None<T extends never> = T;
+export type SqliteRowsMatch = None<Mismatched<typeof schema_sqlite_d_exports>>;
+//#endregion

package/dist/portable.js

@@ -0,0 +1,12 @@
+import { n as trackCommits } from "./commits-BuW-NL3n.js";
+//#region src/portable.ts
+/** Some of a schema's tables, read as their Postgres twins. */
+function asPostgres(tables) {
+	return tables;
+}
+/** A SQLite database, read as a Postgres one. */
+function asPostgresDatabase(db) {
+	return trackCommits(db);
+}
+//#endregion
+export { asPostgres, asPostgresDatabase };

package/dist/relations-DqgxtlKu.js

@@ -0,0 +1,58 @@
+import { relations, sql } from "drizzle-orm";
+//#region src/relations.ts
+/**
+* What both schemas share beyond their columns: the relations and the
+* one generated column.
+*
+* Relations are for Drizzle's relational queries (`db.query.syncs
+* .findMany({ with })`), which read a row and what hangs off it in one
+* statement on every dialect. They add no constraints; the foreign keys in
+* each schema do that. Each schema calls this with its own tables, so a
+* relational query on SQLite joins SQLite tables.
+*/
+function relationsOf(t) {
+	return {
+		environmentsRelations: relations(t.environments, ({ one }) => ({ project: one(t.projects, {
+			fields: [t.environments.projectId],
+			references: [t.projects.id]
+		}) })),
+		secretsRelations: relations(t.secrets, ({ one }) => ({
+			project: one(t.projects, {
+				fields: [t.secrets.projectId],
+				references: [t.projects.id]
+			}),
+			environment: one(t.environments, {
+				fields: [t.secrets.environmentId],
+				references: [t.environments.id]
+			})
+		})),
+		syncsRelations: relations(t.syncs, ({ one, many }) => ({
+			project: one(t.projects, {
+				fields: [t.syncs.projectId],
+				references: [t.projects.id]
+			}),
+			environment: one(t.environments, {
+				fields: [t.syncs.environmentId],
+				references: [t.environments.id]
+			}),
+			credential: one(t.secrets, {
+				fields: [t.syncs.credentialSecretId],
+				references: [t.secrets.id]
+			}),
+			keys: many(t.syncKeys)
+		})),
+		syncKeysRelations: relations(t.syncKeys, ({ one }) => ({ sync: one(t.syncs, {
+			fields: [t.syncKeys.syncId],
+			references: [t.syncs.id]
+		}) }))
+	};
+}
+/**
+* `identities.active_subject`: the subject while the account is bound, null
+* once revoked. A unique index on (provider, issuer_hash, active_subject)
+* binds an account to one person at a time. Plain column names, so the
+* expression reads the same on both databases.
+*/
+const ACTIVE_SUBJECT = sql`CASE WHEN revoked_at IS NULL THEN subject END`;
+//#endregion
+export { relationsOf as n, ACTIVE_SUBJECT as t };

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };