@hexclave/shared 1.0.41 → 1.0.43

package/dist/config/schema.js

@@ -1,7 +1,7 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../rolldown-runtime-D6vf50IK.js");
 let yup = require("yup");
-yup = require_chunk.__toESM(yup);
+yup = require_rolldown_runtime.__toESM(yup);
 let ___utils_errors_js = require("../utils/errors.js");
 let ___utils_objects_js = require("../utils/objects.js");
 let ___apps_apps_config_js = require("../apps/apps-config.js");
@@ -10,12 +10,11 @@ let ___utils_strings_js = require("../utils/strings.js");
 let __format_js = require("./format.js");
 let ___helpers_emails_js = require("../helpers/emails.js");
 let ___schema_fields_js = require("../schema-fields.js");
-___schema_fields_js = require_chunk.__toESM(___schema_fields_js);
+___schema_fields_js = require_rolldown_runtime.__toESM(___schema_fields_js);
 let ___utils_oauth_js = require("../utils/oauth.js");
 let ___utils_results_js = require("../utils/results.js");
 let ___utils_types_js = require("../utils/types.js");
 let __migrate_catalogs_to_product_lines_js = require("./migrate-catalogs-to-product-lines.js");
-
 //#region src/config/schema.ts
 const configLevels = [
 	"project",
@@ -129,55 +128,6 @@ const branchPaymentsSchema = (0, ___schema_fields_js.yupObject)({
 	}
 	return true;
 });
-(void 0)?.test("branchPaymentsSchema accepts partial payments config without products", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({ blockNewPurchases: true }, { abortEarly: false })).resolves.toMatchObject({ blockNewPurchases: true });
-});
-(void 0)?.test("branchPaymentsSchema accepts product lines without products", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({ productLines: { pro: {
-		displayName: "Pro",
-		customerType: "user"
-	} } }, { abortEarly: false })).resolves.toMatchObject({ productLines: { pro: {
-		displayName: "Pro",
-		customerType: "user"
-	} } });
-});
-(void 0)?.test("branchPaymentsSchema rejects a product that references a missing product line", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({ products: { pro: {
-		customerType: "user",
-		productLineId: "missing-line",
-		prices: {}
-	} } }, { abortEarly: false })).rejects.toThrowErrorMatchingInlineSnapshot(`[ValidationError: Product "pro" specifies product line ID "missing-line", but that product line does not exist]`);
-});
-(void 0)?.test("branchPaymentsSchema rejects null product entries without throwing a raw TypeError", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({ products: { pro: null } }, { abortEarly: false })).rejects.toThrowErrorMatchingInlineSnapshot(`[ValidationError: products cannot be null]`);
-});
-(void 0)?.test("branchPaymentsSchema rejects null product line entries without throwing a raw TypeError", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({
-		productLines: { teamLine: null },
-		products: { pro: {
-			customerType: "user",
-			productLineId: "teamLine",
-			prices: {}
-		} }
-	}, { abortEarly: false })).rejects.toThrowErrorMatchingInlineSnapshot(`[ValidationError: productLines cannot be null]`);
-});
-(void 0)?.test("branchPaymentsSchema rejects a product whose customer type differs from its product line", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({
-		productLines: { teamLine: { customerType: "team" } },
-		products: { pro: {
-			customerType: "user",
-			productLineId: "teamLine",
-			prices: {}
-		} }
-	}, { abortEarly: false })).rejects.toThrowErrorMatchingInlineSnapshot(`[ValidationError: Product "pro" has customer type "user" but its product line "teamLine" has customer type "team"]`);
-});
-(void 0)?.test("branchPaymentsSchema lets productLineId schema reject empty IDs", async ({ expect }) => {
-	await expect(branchPaymentsSchema.validate({ products: { pro: {
-		customerType: "user",
-		productLineId: "",
-		prices: {}
-	} } }, { abortEarly: false })).rejects.toThrowErrorMatchingInlineSnapshot(`[ValidationError: productLineId must contain only letters, numbers, underscores, and hyphens, and not start with a hyphen]`);
-});
 const branchDomain = (0, ___schema_fields_js.yupObject)({});
 const branchOnboardingSchema = (0, ___schema_fields_js.yupObject)({ requireEmailVerification: (0, ___schema_fields_js.yupBoolean)() });
 const branchConfigSchema = canNoLongerBeOverridden(projectConfigSchema, ["sourceOfTruth", "project"]).concat((0, ___schema_fields_js.yupObject)({
@@ -315,16 +265,6 @@ function migrateConfigOverride(type, oldUnmigratedConfigOverride) {
 	if (type === "project") res = removeProperty(res, (p) => p[0] === "sourceOfTruth");
 	return res;
 }
-(void 0)?.test("migrateConfigOverride removes legacy sourceOfTruth overrides", ({ expect }) => {
-	expect(migrateConfigOverride("project", { sourceOfTruth: {
-		type: "neon",
-		connectionStrings: { main: "postgres://user:password@neon.example.com/database" }
-	} })).toEqual({});
-	expect(migrateConfigOverride("project", {
-		"sourceOfTruth.type": "postgres",
-		"sourceOfTruth.connectionString": "postgres://user:password@host:5432/database"
-	})).toEqual({});
-});
 function removeProperty(obj, pathCond) {
 	return mapProperty(obj, pathCond, () => void 0);
 }
@@ -340,21 +280,6 @@ function mapProperty(obj, pathCond, mapper) {
 	}
 	return res;
 }
-(void 0)?.test("mapProperty - basic property mapping", ({ expect }) => {
-	expect(mapProperty({ a: { b: { c: 1 } } }, (p) => p.join(".") === "a.b.c", (value) => value + 1)).toEqual({ a: { b: { c: 2 } } });
-	expect(mapProperty({ a: { b: { c: 1 } } }, (p) => p.join(".") === "a.b.d", (value) => value + 1)).toEqual({ a: { b: { c: 1 } } });
-	expect(mapProperty({ x: 5 }, (p) => p.join(".") === "x", (value) => value * 2)).toEqual({ x: 10 });
-	expect(mapProperty({ a: { b: { c: 1 } } }, (p) => p.join(".") === "b.c", (value) => value * 10)).toEqual({ a: { b: { c: 1 } } });
-	expect(mapProperty({ a: 1 }, (p) => p.join(".") === "b.c", (value) => value)).toEqual({ a: 1 });
-	expect(mapProperty({ "a.b": { c: 1 } }, (p) => p.join(".") === "a.b.c", (value) => value + 1)).toEqual({ "a.b": { c: 2 } });
-	expect(mapProperty({ a: { b: { c: 1 } } }, (p) => p.length === 3 && p[0] === "a" && p[1] === "b", (value) => value + 1)).toEqual({ a: { b: { c: 2 } } });
-	const sentinelToEmpty = (v) => v === "include-by-default" ? {} : v;
-	const sentinelPred = (p) => p.length >= 4 && p[0] === "payments" && p[1] === "products" && p[p.length - 1] === "prices";
-	expect(mapProperty({ "payments.products.x.prices": "include-by-default" }, sentinelPred, sentinelToEmpty)).toEqual({ "payments.products.x.prices": {} });
-	expect(mapProperty({ payments: { products: { x: { prices: "include-by-default" } } } }, sentinelPred, sentinelToEmpty)).toEqual({ payments: { products: { x: { prices: {} } } } });
-	expect(mapProperty({ "payments.products": { x: { prices: "include-by-default" } } }, sentinelPred, sentinelToEmpty)).toEqual({ "payments.products": { x: { prices: {} } } });
-	expect(mapProperty({ "payments.products.my.product.prices": "include-by-default" }, sentinelPred, sentinelToEmpty)).toEqual({ "payments.products.my.product.prices": {} });
-});
 function renameProperty(obj, oldPath, newName) {
 	const pathCond = typeof oldPath === "function" ? oldPath : (p) => p.join(".") === oldPath;
 	const pathMapper = typeof newName === "function" ? newName : (p) => newName;
@@ -374,40 +299,6 @@ function renameProperty(obj, oldPath, newName) {
 	}
 	return res;
 }
-(void 0)?.test("renameProperty", ({ expect }) => {
-	expect(renameProperty({ a: 1 }, "a", "b")).toEqual({ b: 1 });
-	expect(renameProperty({ b: { c: 1 } }, "b.c", "d")).toEqual({ b: { d: 1 } });
-	expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c", "d")).toEqual({ a: { b: { d: 1 } } });
-	expect(renameProperty({ a: { b: { c: 1 } } }, "a.b.c.d", "e")).toEqual({ a: { b: { c: 1 } } });
-	expect(renameProperty({ a: {
-		b: { c: 1 },
-		"b.c": 2
-	} }, "b.c", "d")).toEqual({ a: {
-		b: { c: 1 },
-		"b.c": 2
-	} });
-	expect(renameProperty({ a: { "b.c.d": 2 } }, "a.b.c", "e")).toEqual({ a: { "b.e.d": 2 } });
-	expect(renameProperty({ a: {
-		b: { c: 1 },
-		"b.c": 2
-	} }, "a.b.c", "d")).toEqual({ a: {
-		b: { d: 1 },
-		"b.d": 2
-	} });
-	expect(renameProperty({ a: { b: {
-		c: 1,
-		d: 2
-	} } }, "a.b.c", "d")).toEqual({ a: { b: { d: 2 } } });
-	expect(renameProperty({ a: { b: {
-		d: 2,
-		c: 1
-	} } }, "a.b.c", "d")).toEqual({ a: { b: { d: 1 } } });
-	expect(renameProperty({ a: 1 }, (p) => p.length === 1 && p[0] === "a", (p) => "b")).toEqual({ b: 1 });
-	expect(renameProperty({ a: { b: { c: 1 } } }, (p) => p.length === 3 && p[0] === "a" && p[1] === "b" && p[2] === "c", (p) => "d")).toEqual({ a: { b: { d: 1 } } });
-	expect(renameProperty({ a: { b: { c: 1 } } }, (p) => false, (p) => "e")).toEqual({ a: { b: { c: 1 } } });
-	expect(renameProperty({ a: { b: { a: 1 } } }, (p) => p[p.length - 1] === "a", (p) => "c")).toEqual({ c: { b: { c: 1 } } });
-	expect(() => renameProperty({ a: 1 }, "a", "b.c")).toThrow();
-});
 const projectConfigDefaults = {
 	sourceOfTruth: { type: "hosted" },
 	project: { requirePublishableClientKey: false }
@@ -565,14 +456,6 @@ function deepReplaceFunctionsWithObjects(obj, paths = []) {
 		...obj
 	}, (v, k) => (0, ___utils_objects_js.isObjectLike)(v) ? deepReplaceFunctionsWithObjects(v, subPaths(k)) : v);
 }
-(void 0)?.test("deepReplaceFunctionsWithObjects", ({ expect }) => {
-	expect(deepReplaceFunctionsWithObjects(() => {})).toEqual({});
-	expect(deepReplaceFunctionsWithObjects({ a: 3 })).toEqual({ a: 3 });
-	expect(deepReplaceFunctionsWithObjects({ a: () => ({ b: 1 }) })).toEqual({ a: {} });
-	expect(deepReplaceFunctionsWithObjects({ a: () => ({ b: 1 }) }, ["a.c.d"])).toEqual({ a: { c: { b: 1 } } });
-	expect(deepReplaceFunctionsWithObjects(() => ({ b: 1 }), ["a"])).toEqual({ a: { b: 1 } });
-	expect(deepReplaceFunctionsWithObjects({ a: (0, ___utils_objects_js.typedAssign)(() => ({}), { b: { c: 1 } }) })).toEqual({ a: { b: { c: 1 } } });
-});
 function applyDefaults(defaults, config) {
 	const res = deepReplaceFunctionsWithObjects(defaults);
 	outer: for (const [key, mergeValue] of Object.entries(config)) if (!(0, ___utils_objects_js.isObjectLike)(mergeValue) && mergeValue !== null) (0, ___utils_objects_js.set)(res, key, mergeValue);
@@ -594,231 +477,6 @@ function applyDefaults(defaults, config) {
 	}
 	return res;
 }
-(void 0)?.test("applyDefaults", ({ expect }) => {
-	expect(applyDefaults({ a: 1 }, { a: 2 })).toEqual({ a: 2 });
-	expect(applyDefaults({ a: 1 }, { a: null })).toEqual({ a: 1 });
-	expect(applyDefaults({}, { a: 1 })).toEqual({ a: 1 });
-	expect(applyDefaults({ a: { b: 1 } }, { a: { b: 2 } })).toEqual({ a: { b: 2 } });
-	expect(applyDefaults({ a: { b: 1 } }, { a: { c: 2 } })).toEqual({ a: {
-		b: 1,
-		c: 2
-	} });
-	expect(applyDefaults({ a: { b: {
-		c: 1,
-		d: 2
-	} } }, { a: { b: {
-		d: 3,
-		e: 4
-	} } })).toEqual({ a: { b: {
-		c: 1,
-		d: 3,
-		e: 4
-	} } });
-	expect(applyDefaults((key) => ({ b: key }), { a: {} })).toEqual({ a: { b: "a" } });
-	expect(applyDefaults((key) => ({ b: key }), { a: null })).toEqual({ a: null });
-	expect(applyDefaults((key1) => (key2) => ({
-		a: key1,
-		b: key2
-	}), { c: { d: {} } })).toEqual({ c: { d: {
-		a: "c",
-		b: "d"
-	} } });
-	expect(applyDefaults({ a: (key) => ({ b: key }) }, { a: { c: { d: 1 } } })).toEqual({ a: { c: {
-		b: "c",
-		d: 1
-	} } });
-	expect(applyDefaults({ a: (key) => ({ b: key }) }, {})).toEqual({ a: {} });
-	expect(applyDefaults({ a: (key) => ({ b: key }) }, { a: null })).toEqual({ a: {} });
-	expect(applyDefaults({ a: (key) => ({ c: key }) }, { a: { b: null } })).toEqual({ a: { b: null } });
-	expect(applyDefaults({ a: { b: (key) => ({ b: key }) } }, {})).toEqual({ a: { b: {} } });
-	expect(applyDefaults((0, ___utils_objects_js.typedAssign)(() => ({ b: 1 }), { a: {
-		b: 1,
-		c: 2
-	} }), { a: {} })).toEqual({ a: {
-		b: 1,
-		c: 2
-	} });
-	expect(applyDefaults((0, ___utils_objects_js.typedAssign)(() => ({ b: 1 }), { a: {
-		b: 1,
-		c: 2
-	} }), { d: {} })).toEqual({
-		a: {
-			b: 1,
-			c: 2
-		},
-		d: { b: 1 }
-	});
-	expect(applyDefaults({ a: { b: 1 } }, { "a.c": 2 })).toEqual({
-		a: { b: 1 },
-		"a.c": 2
-	});
-	expect(applyDefaults({ a: { b: 1 } }, { "a.c": null })).toEqual({
-		a: { b: 1 },
-		"a.c": null
-	});
-	expect(applyDefaults({ a: { b: 1 } }, {
-		a: { b: 2 },
-		"a.b": null
-	})).toEqual({
-		a: { b: 2 },
-		"a.b": 1
-	});
-	expect(applyDefaults({ a: { b: { c: 1 } } }, {
-		a: { b: { c: 2 } },
-		"a.b.c": null
-	})).toEqual({
-		a: { b: { c: 2 } },
-		"a.b.c": 1
-	});
-	expect(applyDefaults({}, {
-		a: { b: 2 },
-		"a.b": null
-	})).toEqual({
-		a: { b: 2 },
-		"a.b": null
-	});
-	expect(applyDefaults({ a: {
-		b: 1,
-		c: 2
-	} }, { "a.c": null })).toEqual({
-		a: {
-			b: 1,
-			c: 2
-		},
-		"a.c": 2
-	});
-	expect(applyDefaults({ a: {
-		b: 1,
-		c: () => {}
-	} }, { "a.c": null })).toEqual({
-		a: {
-			b: 1,
-			c: {}
-		},
-		"a.c": {}
-	});
-	expect(applyDefaults({ a: {
-		b: 1,
-		c: () => {}
-	} }, { "a.c.d": null })).toEqual({
-		a: {
-			b: 1,
-			c: {}
-		},
-		"a.c.d": null
-	});
-	expect(applyDefaults({ a: { b: 1 } }, { "a.b": null })).toEqual({
-		a: { b: 1 },
-		"a.b": 1
-	});
-	expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": null })).toEqual({
-		a: { b: { c: 1 } },
-		"a.b": { c: 1 }
-	});
-	expect(applyDefaults({ a: {} }, { "a.b": null })).toEqual({
-		a: {},
-		"a.b": null
-	});
-	expect(applyDefaults({ a: {} }, {
-		"a": { b: 1 },
-		"a.b": null
-	})).toEqual({
-		a: { b: 1 },
-		"a.b": null
-	});
-	expect(applyDefaults({ a: 1 }, { "a.b": null })).toEqual({
-		a: 1,
-		"a.b": null
-	});
-	expect(applyDefaults({ a: 1 }, { "a.b": 2 })).toEqual({
-		a: 1,
-		"a.b": 2
-	});
-	expect(applyDefaults({ a: null }, { "a.b": 2 })).toEqual({
-		a: null,
-		"a.b": 2
-	});
-	expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": { d: 2 } })).toEqual({
-		a: { b: { c: 1 } },
-		"a.b": {
-			c: 1,
-			d: 2
-		}
-	});
-	expect(applyDefaults({ a: { b: { c: 1 } } }, { "a.b": null })).toEqual({
-		a: { b: { c: 1 } },
-		"a.b": { c: 1 }
-	});
-	expect(applyDefaults({ a: { b: { c: { d: 1 } } } }, { "a.b.c": {} })).toEqual({
-		a: { b: { c: { d: 1 } } },
-		"a.b.c": { d: 1 }
-	});
-	expect(applyDefaults({ a: () => ({ c: 1 }) }, { "a.b": { d: 2 } })).toEqual({
-		a: {},
-		"a.b": {
-			c: 1,
-			d: 2
-		}
-	});
-	expect(applyDefaults({ a: () => () => ({ d: 1 }) }, { "a.b": null })).toEqual({
-		a: {},
-		"a.b": null
-	});
-	expect(applyDefaults({ a: () => () => ({ d: 1 }) }, { "a.b.c": {} })).toEqual({
-		a: {},
-		"a.b.c": { d: 1 }
-	});
-	expect(applyDefaults({ a: { b: () => ({
-		c: 1,
-		d: 2
-	}) } }, { "a.b.x-y.c": 3 })).toEqual({
-		a: { b: {} },
-		"a.b.x-y.c": 3
-	});
-	expect(applyDefaults({ a: () => ({ c: 1 }) }, { "a.b.d": 2 })).toEqual({
-		a: {},
-		"a.b.d": 2
-	});
-	expect(applyDefaults({ a: () => ({ c: 1 }) }, {
-		"a.b.d": 2,
-		"a.e.d": 3
-	})).toEqual({
-		a: {},
-		"a.b.d": 2,
-		"a.e.d": 3
-	});
-	expect(applyDefaults({ a: () => ({ c: 1 }) }, {
-		"a.b.d": 2,
-		a: { b: { d: 3 } }
-	})).toEqual({
-		a: { b: {
-			c: 1,
-			d: 3
-		} },
-		"a.b.d": 2
-	});
-	expect(applyDefaults({ a: () => ({ c: 1 }) }, {
-		"a.b.d": 2,
-		a: { e: { d: 3 } }
-	})).toEqual({
-		a: { e: {
-			c: 1,
-			d: 3
-		} },
-		"a.b.d": 2
-	});
-	expect(applyDefaults({ a: () => ({ c: 1 }) }, {
-		"a.b": { d: { e: 2 } },
-		"a.b.d": null
-	})).toEqual({
-		a: {},
-		"a.b": {
-			c: 1,
-			d: { e: 2 }
-		},
-		"a.b.d": null
-	});
-});
 function applyProjectDefaults(config) {
 	return applyDefaults(projectConfigDefaults, config);
 }
@@ -952,10 +610,7 @@ async function getConfigOverrideErrors(schema, configOverride, options = {}) {
 				return (0, ___schema_fields_js.yupUnion)(...nonObjectSchemas.map(([index, s]) => getRestrictedSchema(path + `|variant-${index}|`, s)), ...objectSchemas.length > 0 ? [getRestrictedSchema(path + (nonObjectSchemas.length > 0 ? `|variant|` : ""), mergedObjectSchema)] : []);
 			}
 			case "record": return (0, ___schema_fields_js.yupRecord)(getRestrictedSchema(path + ".key", schemaInfo.keySchema), getRestrictedSchema(path + ".value", schemaInfo.valueSchema));
-			case "object": {
-				const objectSchema = schema;
-				return (0, ___schema_fields_js.yupObject)(Object.fromEntries(Object.entries(objectSchema.fields).map(([key, value]) => [key, getRestrictedSchema(path + "." + key, value)])));
-			}
+			case "object": return (0, ___schema_fields_js.yupObject)(Object.fromEntries(Object.entries(schema.fields).map(([key, value]) => [key, getRestrictedSchema(path + "." + key, value)])));
 			case "never": return (0, ___schema_fields_js.yupNever)();
 			default: throw new ___utils_errors_js.HexclaveAssertionError(`Unknown schema info at path ${path}: ${JSON.stringify(schemaInfo)}`, {
 				schemaInfo,
@@ -1072,7 +727,6 @@ async function getIncompleteConfigWarnings(schema, incompleteConfig) {
 (0, ___utils_types_js.typeAssert)()();
 (0, ___utils_types_js.typeAssert)()();
 (0, ___utils_types_js.typeAssertExtends)()();
-
 //#endregion
 exports.applyBranchDefaults = applyBranchDefaults;
 exports.applyEnvironmentDefaults = applyEnvironmentDefaults;
@@ -1092,4 +746,5 @@ exports.sanitizeBranchConfig = sanitizeBranchConfig;
 exports.sanitizeEnvironmentConfig = sanitizeEnvironmentConfig;
 exports.sanitizeOrganizationConfig = sanitizeOrganizationConfig;
 exports.sanitizeProjectConfig = sanitizeProjectConfig;
+
 //# sourceMappingURL=schema.js.map