@coffre/cli 0.1.1 → 0.1.3

package/dist/portable-CPh2thNN.js

@@ -0,0 +1,87 @@
+import { G as sql, l as relations } from "./relations-CJCGPRst.js";
+//#region ../db/dist/commits-BuW-NL3n.js
+const pending = /* @__PURE__ */ new WeakMap();
+/** `db`, its transactions tracked for `afterCommit`. */
+function trackCommits(db, outer = null) {
+	const run = db.transaction.bind(db);
+	const transaction = async (work, ...rest) => {
+		const list = [];
+		const result = await run((tx) => {
+			pending.set(tx, list);
+			return work(trackCommits(tx, list));
+		}, ...rest);
+		if (outer !== null) outer.push(...list);
+		else for (const then of list) then();
+		return result;
+	};
+	db.transaction = transaction;
+	return db;
+}
+//#endregion
+//#region ../db/dist/relations-DqgxtlKu.js
+/**
+* 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
+//#region ../db/dist/portable.js
+/** 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 { trackCommits as a, relationsOf as i, asPostgresDatabase as n, ACTIVE_SUBJECT as r, asPostgres as t };