@prisma-next/family-mongo 0.0.1 → 0.3.0-dev.162

package/dist/control.mjs

@@ -0,0 +1,647 @@
+import { mongoEmission } from "@prisma-next/mongo-emitter";
+import { MongoMigrationPlanner, MongoMigrationRunner, contractToMongoSchemaIR, initMarker, introspectSchema, readMarker, updateMarker } from "@prisma-next/adapter-mongo/control";
+import { SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_SCHEMA_FAILURE, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";
+import { validateMongoContract } from "@prisma-next/mongo-contract";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
+import mongoTargetDescriptorMeta from "@prisma-next/target-mongo/pack";
+
+//#region src/core/schema-diff.ts
+function diffMongoSchemas(live, expected, strict) {
+	const issues = [];
+	const collectionChildren = [];
+	let pass = 0;
+	let warn = 0;
+	let fail = 0;
+	const allNames = new Set([...live.collectionNames, ...expected.collectionNames]);
+	for (const name of [...allNames].sort()) {
+		const liveColl = live.collection(name);
+		const expectedColl = expected.collection(name);
+		if (!liveColl && expectedColl) {
+			issues.push({
+				kind: "missing_table",
+				table: name,
+				message: `Collection "${name}" is missing from the database`
+			});
+			collectionChildren.push({
+				status: "fail",
+				kind: "collection",
+				name,
+				contractPath: `storage.collections.${name}`,
+				code: "MISSING_COLLECTION",
+				message: `Collection "${name}" is missing`,
+				expected: name,
+				actual: null,
+				children: []
+			});
+			fail++;
+			continue;
+		}
+		if (liveColl && !expectedColl) {
+			const status = strict ? "fail" : "warn";
+			issues.push({
+				kind: "extra_table",
+				table: name,
+				message: `Extra collection "${name}" exists in the database but not in the contract`
+			});
+			collectionChildren.push({
+				status,
+				kind: "collection",
+				name,
+				contractPath: `storage.collections.${name}`,
+				code: "EXTRA_COLLECTION",
+				message: `Extra collection "${name}" found`,
+				expected: null,
+				actual: name,
+				children: []
+			});
+			if (status === "fail") fail++;
+			else warn++;
+			continue;
+		}
+		const lc = liveColl;
+		const ec = expectedColl;
+		const indexChildren = diffIndexes(name, lc, ec, strict, issues);
+		const validatorChildren = diffValidator(name, lc, ec, strict, issues);
+		const optionsChildren = diffOptions(name, lc, ec, strict, issues);
+		const children = [
+			...indexChildren,
+			...validatorChildren,
+			...optionsChildren
+		];
+		const worstStatus = children.reduce((s, c) => c.status === "fail" ? "fail" : c.status === "warn" && s !== "fail" ? "warn" : s, "pass");
+		for (const c of children) if (c.status === "pass") pass++;
+		else if (c.status === "warn") warn++;
+		else fail++;
+		if (children.length === 0) pass++;
+		collectionChildren.push({
+			status: worstStatus,
+			kind: "collection",
+			name,
+			contractPath: `storage.collections.${name}`,
+			code: worstStatus === "pass" ? "MATCH" : "DRIFT",
+			message: worstStatus === "pass" ? `Collection "${name}" matches` : `Collection "${name}" has drift`,
+			expected: name,
+			actual: name,
+			children
+		});
+	}
+	const rootStatus = fail > 0 ? "fail" : warn > 0 ? "warn" : "pass";
+	const totalNodes = pass + warn + fail + collectionChildren.length;
+	return {
+		root: {
+			status: rootStatus,
+			kind: "root",
+			name: "mongo-schema",
+			contractPath: "storage",
+			code: rootStatus === "pass" ? "MATCH" : "DRIFT",
+			message: rootStatus === "pass" ? "Schema matches" : "Schema has drift",
+			expected: null,
+			actual: null,
+			children: collectionChildren
+		},
+		issues,
+		counts: {
+			pass,
+			warn,
+			fail,
+			totalNodes
+		}
+	};
+}
+function buildIndexLookupKey(index) {
+	const keys = index.keys.map((k) => `${k.field}:${k.direction}`).join(",");
+	const opts = [
+		index.unique ? "unique" : "",
+		index.sparse ? "sparse" : "",
+		index.expireAfterSeconds != null ? `ttl:${index.expireAfterSeconds}` : "",
+		index.partialFilterExpression ? `pfe:${canonicalize(index.partialFilterExpression)}` : "",
+		index.wildcardProjection ? `wp:${canonicalize(index.wildcardProjection)}` : "",
+		index.collation ? `col:${canonicalize(index.collation)}` : "",
+		index.weights ? `wt:${canonicalize(index.weights)}` : "",
+		index.default_language ? `dl:${index.default_language}` : "",
+		index.language_override ? `lo:${index.language_override}` : ""
+	].filter(Boolean).join(";");
+	return opts ? `${keys}|${opts}` : keys;
+}
+function formatIndexName(index) {
+	return index.keys.map((k) => `${k.field}:${k.direction}`).join(", ");
+}
+function diffIndexes(collName, live, expected, strict, issues) {
+	const nodes = [];
+	const liveLookup = /* @__PURE__ */ new Map();
+	for (const idx of live.indexes) liveLookup.set(buildIndexLookupKey(idx), idx);
+	const expectedLookup = /* @__PURE__ */ new Map();
+	for (const idx of expected.indexes) expectedLookup.set(buildIndexLookupKey(idx), idx);
+	for (const [key, idx] of expectedLookup) if (liveLookup.has(key)) nodes.push({
+		status: "pass",
+		kind: "index",
+		name: formatIndexName(idx),
+		contractPath: `storage.collections.${collName}.indexes`,
+		code: "MATCH",
+		message: `Index ${formatIndexName(idx)} matches`,
+		expected: key,
+		actual: key,
+		children: []
+	});
+	else {
+		issues.push({
+			kind: "index_mismatch",
+			table: collName,
+			indexOrConstraint: formatIndexName(idx),
+			message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`
+		});
+		nodes.push({
+			status: "fail",
+			kind: "index",
+			name: formatIndexName(idx),
+			contractPath: `storage.collections.${collName}.indexes`,
+			code: "MISSING_INDEX",
+			message: `Index ${formatIndexName(idx)} missing`,
+			expected: key,
+			actual: null,
+			children: []
+		});
+	}
+	for (const [key, idx] of liveLookup) if (!expectedLookup.has(key)) {
+		const status = strict ? "fail" : "warn";
+		issues.push({
+			kind: "extra_index",
+			table: collName,
+			indexOrConstraint: formatIndexName(idx),
+			message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`
+		});
+		nodes.push({
+			status,
+			kind: "index",
+			name: formatIndexName(idx),
+			contractPath: `storage.collections.${collName}.indexes`,
+			code: "EXTRA_INDEX",
+			message: `Extra index ${formatIndexName(idx)}`,
+			expected: null,
+			actual: key,
+			children: []
+		});
+	}
+	return nodes;
+}
+function diffValidator(collName, live, expected, strict, issues) {
+	if (!live.validator && !expected.validator) return [];
+	if (expected.validator && !live.validator) {
+		issues.push({
+			kind: "type_missing",
+			table: collName,
+			message: `Validator missing on collection "${collName}"`
+		});
+		return [{
+			status: "fail",
+			kind: "validator",
+			name: "validator",
+			contractPath: `storage.collections.${collName}.validator`,
+			code: "MISSING_VALIDATOR",
+			message: "Validator missing",
+			expected: canonicalize(expected.validator.jsonSchema),
+			actual: null,
+			children: []
+		}];
+	}
+	if (!expected.validator && live.validator) {
+		const status = strict ? "fail" : "warn";
+		issues.push({
+			kind: "extra_validator",
+			table: collName,
+			message: `Extra validator on collection "${collName}"`
+		});
+		return [{
+			status,
+			kind: "validator",
+			name: "validator",
+			contractPath: `storage.collections.${collName}.validator`,
+			code: "EXTRA_VALIDATOR",
+			message: "Extra validator found",
+			expected: null,
+			actual: canonicalize(live.validator.jsonSchema),
+			children: []
+		}];
+	}
+	const liveVal = live.validator;
+	const expectedVal = expected.validator;
+	const liveSchema = canonicalize(liveVal.jsonSchema);
+	const expectedSchema = canonicalize(expectedVal.jsonSchema);
+	if (liveSchema !== expectedSchema || liveVal.validationLevel !== expectedVal.validationLevel || liveVal.validationAction !== expectedVal.validationAction) {
+		issues.push({
+			kind: "type_mismatch",
+			table: collName,
+			expected: expectedSchema,
+			actual: liveSchema,
+			message: `Validator mismatch on collection "${collName}"`
+		});
+		return [{
+			status: "fail",
+			kind: "validator",
+			name: "validator",
+			contractPath: `storage.collections.${collName}.validator`,
+			code: "VALIDATOR_MISMATCH",
+			message: "Validator mismatch",
+			expected: {
+				jsonSchema: expectedVal.jsonSchema,
+				validationLevel: expectedVal.validationLevel,
+				validationAction: expectedVal.validationAction
+			},
+			actual: {
+				jsonSchema: liveVal.jsonSchema,
+				validationLevel: liveVal.validationLevel,
+				validationAction: liveVal.validationAction
+			},
+			children: []
+		}];
+	}
+	return [{
+		status: "pass",
+		kind: "validator",
+		name: "validator",
+		contractPath: `storage.collections.${collName}.validator`,
+		code: "MATCH",
+		message: "Validator matches",
+		expected: expectedSchema,
+		actual: liveSchema,
+		children: []
+	}];
+}
+function diffOptions(collName, live, expected, strict, issues) {
+	if (!live.options && !expected.options) return [];
+	if (!expected.options && live.options) {
+		const status = strict ? "fail" : "warn";
+		issues.push({
+			kind: "type_mismatch",
+			table: collName,
+			actual: canonicalize(live.options),
+			message: `Extra collection options on "${collName}"`
+		});
+		return [{
+			status,
+			kind: "options",
+			name: "options",
+			contractPath: `storage.collections.${collName}.options`,
+			code: "EXTRA_OPTIONS",
+			message: "Extra collection options found",
+			expected: null,
+			actual: live.options,
+			children: []
+		}];
+	}
+	if (deepEqual(live.options, expected.options)) return [{
+		status: "pass",
+		kind: "options",
+		name: "options",
+		contractPath: `storage.collections.${collName}.options`,
+		code: "MATCH",
+		message: "Collection options match",
+		expected: canonicalize(expected.options),
+		actual: canonicalize(live.options),
+		children: []
+	}];
+	issues.push({
+		kind: "type_mismatch",
+		table: collName,
+		expected: canonicalize(expected.options),
+		actual: canonicalize(live.options),
+		message: `Collection options mismatch on "${collName}"`
+	});
+	return [{
+		status: "fail",
+		kind: "options",
+		name: "options",
+		contractPath: `storage.collections.${collName}.options`,
+		code: "OPTIONS_MISMATCH",
+		message: "Collection options mismatch",
+		expected: expected.options,
+		actual: live.options,
+		children: []
+	}];
+}
+
+//#endregion
+//#region src/core/schema-to-view.ts
+function mongoSchemaToView(schema) {
+	const collectionNodes = schema.collections.map((collection) => collectionToSchemaNode(collection.name, collection));
+	return { root: new SchemaTreeNode({
+		kind: "root",
+		id: "mongo-schema",
+		label: "database",
+		...ifDefined("children", collectionNodes.length > 0 ? collectionNodes : void 0)
+	}) };
+}
+function collectionToSchemaNode(name, collection) {
+	const children = [];
+	for (const index of collection.indexes) {
+		const keysSummary = index.keys.map((k) => {
+			if (k.direction === 1) return k.field;
+			if (k.direction === -1) return `${k.field} desc`;
+			return `${k.field} ${k.direction}`;
+		}).join(", ");
+		const prefix = index.unique ? "unique index" : "index";
+		const options = [];
+		if (index.sparse) options.push("sparse");
+		if (index.expireAfterSeconds != null) options.push(`ttl: ${index.expireAfterSeconds}s`);
+		if (index.partialFilterExpression) options.push("partial");
+		const optsSuffix = options.length > 0 ? ` (${options.join(", ")})` : "";
+		children.push(new SchemaTreeNode({
+			kind: "index",
+			id: `index-${name}-${index.keys.map((k) => `${k.field}_${k.direction}`).join("_")}`,
+			label: `${prefix} (${keysSummary})${optsSuffix}`,
+			meta: {
+				keys: index.keys,
+				unique: index.unique,
+				...ifDefined("sparse", index.sparse || void 0),
+				...ifDefined("expireAfterSeconds", index.expireAfterSeconds ?? void 0),
+				...ifDefined("partialFilterExpression", index.partialFilterExpression ?? void 0)
+			}
+		}));
+	}
+	if (collection.validator) {
+		const validatorChildren = [];
+		const jsonSchema = collection.validator.jsonSchema;
+		const properties = jsonSchema["properties"];
+		const required = new Set(jsonSchema["required"] ?? []);
+		if (properties) for (const [propName, propDef] of Object.entries(properties)) {
+			const bsonType = propDef["bsonType"] ?? "unknown";
+			const suffix = required.has(propName) ? " (required)" : "";
+			validatorChildren.push(new SchemaTreeNode({
+				kind: "field",
+				id: `field-${name}-${propName}`,
+				label: `${propName}: ${bsonType}${suffix}`
+			}));
+		}
+		children.push(new SchemaTreeNode({
+			kind: "field",
+			id: `validator-${name}`,
+			label: `validator (level: ${collection.validator.validationLevel}, action: ${collection.validator.validationAction})`,
+			meta: {
+				validationLevel: collection.validator.validationLevel,
+				validationAction: collection.validator.validationAction,
+				jsonSchema: collection.validator.jsonSchema
+			},
+			...ifDefined("children", validatorChildren.length > 0 ? validatorChildren : void 0)
+		}));
+	}
+	if (collection.options) {
+		const opts = collection.options;
+		const optLabels = [];
+		if (opts.capped) optLabels.push("capped");
+		if (opts.timeseries) optLabels.push("timeseries");
+		if (opts.collation) optLabels.push("collation");
+		if (opts.changeStreamPreAndPostImages) optLabels.push("changeStreamPreAndPostImages");
+		if (opts.clusteredIndex) optLabels.push("clusteredIndex");
+		if (optLabels.length > 0) children.push(new SchemaTreeNode({
+			kind: "field",
+			id: `options-${name}`,
+			label: `options (${optLabels.join(", ")})`,
+			meta: {
+				...ifDefined("capped", opts.capped ?? void 0),
+				...ifDefined("timeseries", opts.timeseries ?? void 0),
+				...ifDefined("collation", opts.collation ?? void 0),
+				...ifDefined("changeStreamPreAndPostImages", opts.changeStreamPreAndPostImages ?? void 0),
+				...ifDefined("clusteredIndex", opts.clusteredIndex ?? void 0)
+			}
+		}));
+	}
+	return new SchemaTreeNode({
+		kind: "collection",
+		id: `collection-${name}`,
+		label: `collection ${name}`,
+		...ifDefined("children", children.length > 0 ? children : void 0)
+	});
+}
+
+//#endregion
+//#region src/core/control-instance.ts
+function extractDb(driver) {
+	const mongoDriver = driver;
+	if (!mongoDriver.db) throw new Error("Mongo control driver does not expose a db property. Use createMongoControlDriver() from @prisma-next/adapter-mongo/control.");
+	return mongoDriver.db;
+}
+var MongoFamilyInstance = class {
+	familyId = "mongo";
+	validateContract(contractJson) {
+		return validateMongoContract(contractJson).contract;
+	}
+	async verify(options) {
+		const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = options;
+		const startTime = Date.now();
+		const contract = validateMongoContract(rawContract).contract;
+		const contractStorageHash = contract.storage.storageHash;
+		const contractProfileHash = contract.profileHash;
+		const contractTarget = contract.target;
+		const baseOpts = {
+			contractStorageHash,
+			contractProfileHash,
+			expectedTargetId,
+			contractPath,
+			...ifDefined("configPath", configPath)
+		};
+		if (contractTarget !== expectedTargetId) return buildVerifyResult({
+			...baseOpts,
+			ok: false,
+			code: VERIFY_CODE_TARGET_MISMATCH,
+			summary: "Target mismatch",
+			actualTargetId: contractTarget,
+			totalTime: Date.now() - startTime
+		});
+		const marker = await readMarker(extractDb(driver));
+		if (!marker) return buildVerifyResult({
+			...baseOpts,
+			ok: false,
+			code: VERIFY_CODE_MARKER_MISSING,
+			summary: "Marker missing",
+			totalTime: Date.now() - startTime
+		});
+		if (marker.storageHash !== contractStorageHash) return buildVerifyResult({
+			...baseOpts,
+			ok: false,
+			code: VERIFY_CODE_HASH_MISMATCH,
+			summary: "Hash mismatch",
+			marker,
+			totalTime: Date.now() - startTime
+		});
+		if (contractProfileHash && marker.profileHash !== contractProfileHash) return buildVerifyResult({
+			...baseOpts,
+			ok: false,
+			code: VERIFY_CODE_HASH_MISMATCH,
+			summary: "Hash mismatch",
+			marker,
+			totalTime: Date.now() - startTime
+		});
+		return buildVerifyResult({
+			...baseOpts,
+			ok: true,
+			summary: "Database matches contract",
+			marker,
+			totalTime: Date.now() - startTime
+		});
+	}
+	async schemaVerify(options) {
+		const { driver, contract: rawContract, strict, contractPath, configPath } = options;
+		const startTime = Date.now();
+		const contract = validateMongoContract(rawContract).contract;
+		const { root, issues, counts } = diffMongoSchemas(await introspectSchema(extractDb(driver)), contractToMongoSchemaIR(contract), strict);
+		const ok = counts.fail === 0;
+		return {
+			ok,
+			...ifDefined("code", ok ? void 0 : VERIFY_CODE_SCHEMA_FAILURE),
+			summary: ok ? "Schema matches contract" : `Schema verification found ${counts.fail} issue(s)`,
+			contract: {
+				storageHash: contract.storage.storageHash,
+				...ifDefined("profileHash", contract.profileHash)
+			},
+			target: { expected: contract.target },
+			schema: {
+				issues,
+				root,
+				counts
+			},
+			meta: {
+				...ifDefined("contractPath", contractPath),
+				...ifDefined("configPath", configPath),
+				strict
+			},
+			timings: { total: Date.now() - startTime }
+		};
+	}
+	async sign(options) {
+		const { driver, contract: rawContract, contractPath, configPath } = options;
+		const startTime = Date.now();
+		const contract = validateMongoContract(rawContract).contract;
+		const contractStorageHash = contract.storage.storageHash;
+		const contractProfileHash = contract.profileHash;
+		const db = extractDb(driver);
+		const existingMarker = await readMarker(db);
+		let markerCreated = false;
+		let markerUpdated = false;
+		let previousHashes;
+		if (!existingMarker) {
+			await initMarker(db, {
+				storageHash: contractStorageHash,
+				profileHash: contractProfileHash
+			});
+			markerCreated = true;
+		} else {
+			const storageHashMatches = existingMarker.storageHash === contractStorageHash;
+			const profileHashMatches = existingMarker.profileHash === contractProfileHash;
+			if (!storageHashMatches || !profileHashMatches) {
+				previousHashes = {
+					storageHash: existingMarker.storageHash,
+					profileHash: existingMarker.profileHash
+				};
+				if (!await updateMarker(db, existingMarker.storageHash, {
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash
+				})) throw new Error("CAS conflict: marker was modified by another process during sign");
+				markerUpdated = true;
+			}
+		}
+		let summary;
+		if (markerCreated) summary = "Database signed (marker created)";
+		else if (markerUpdated) summary = `Database signed (marker updated from ${previousHashes?.storageHash ?? "unknown"})`;
+		else summary = "Database already signed with this contract";
+		return {
+			ok: true,
+			summary,
+			contract: {
+				storageHash: contractStorageHash,
+				profileHash: contractProfileHash
+			},
+			target: {
+				expected: contract.target,
+				actual: contract.target
+			},
+			marker: {
+				created: markerCreated,
+				updated: markerUpdated,
+				...ifDefined("previous", previousHashes)
+			},
+			meta: {
+				contractPath,
+				...ifDefined("configPath", configPath)
+			},
+			timings: { total: Date.now() - startTime }
+		};
+	}
+	async readMarker(options) {
+		return readMarker(extractDb(options.driver));
+	}
+	async introspect(options) {
+		return introspectSchema(extractDb(options.driver));
+	}
+	toSchemaView(schema) {
+		return mongoSchemaToView(schema);
+	}
+};
+function buildVerifyResult(opts) {
+	return {
+		ok: opts.ok,
+		...ifDefined("code", opts.code),
+		summary: opts.summary,
+		contract: {
+			storageHash: opts.contractStorageHash,
+			...ifDefined("profileHash", opts.contractProfileHash)
+		},
+		...ifDefined("marker", opts.marker ? {
+			storageHash: opts.marker.storageHash,
+			profileHash: opts.marker.profileHash
+		} : void 0),
+		target: {
+			expected: opts.expectedTargetId,
+			...ifDefined("actual", opts.actualTargetId)
+		},
+		meta: {
+			contractPath: opts.contractPath,
+			...ifDefined("configPath", opts.configPath)
+		},
+		timings: { total: opts.totalTime }
+	};
+}
+function createMongoFamilyInstance(_controlStack) {
+	return new MongoFamilyInstance();
+}
+
+//#endregion
+//#region src/core/control-descriptor.ts
+var MongoFamilyDescriptor = class {
+	kind = "family";
+	id = "mongo";
+	familyId = "mongo";
+	version = "0.0.1";
+	emission = mongoEmission;
+	create(stack) {
+		return createMongoFamilyInstance(stack);
+	}
+};
+const mongoFamilyDescriptor = new MongoFamilyDescriptor();
+
+//#endregion
+//#region src/core/mongo-target-descriptor.ts
+const mongoTargetDescriptor = {
+	...mongoTargetDescriptorMeta,
+	migrations: {
+		createPlanner(_family) {
+			return new MongoMigrationPlanner();
+		},
+		createRunner(_family) {
+			return new MongoMigrationRunner();
+		},
+		contractToSchema(contract) {
+			return contractToMongoSchemaIR(contract);
+		}
+	},
+	create() {
+		return {
+			familyId: "mongo",
+			targetId: "mongo"
+		};
+	}
+};
+
+//#endregion
+export { createMongoFamilyInstance, mongoFamilyDescriptor, mongoTargetDescriptor };
+//# sourceMappingURL=control.mjs.map