@hexclave/shared 1.0.40 → 1.0.42

package/dist/esm/config/schema.js

@@ -12,7 +12,6 @@ import { allProviderTypes } from "../utils/oauth.js";
 import { Result } from "../utils/results.js";
 import { typeAssert, typeAssertExtends, typeAssertIs } from "../utils/types.js";
 import { migrateCatalogsToProductLines } from "./migrate-catalogs-to-product-lines.js";
-
 //#region src/config/schema.ts
 const configLevels = [
 	"project",
@@ -126,55 +125,6 @@ const branchPaymentsSchema = 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 = yupObject({});
 const branchOnboardingSchema = yupObject({ requireEmailVerification: yupBoolean() });
 const branchConfigSchema = canNoLongerBeOverridden(projectConfigSchema, ["sourceOfTruth", "project"]).concat(yupObject({
@@ -312,16 +262,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);
 }
@@ -337,21 +277,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;
@@ -371,40 +296,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 }
@@ -562,14 +453,6 @@ function deepReplaceFunctionsWithObjects(obj, paths = []) {
 		...obj
 	}, (v, k) => 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: 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 (!isObjectLike(mergeValue) && mergeValue !== null) set(res, key, mergeValue);
@@ -591,231 +474,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(typedAssign(() => ({ b: 1 }), { a: {
-		b: 1,
-		c: 2
-	} }), { a: {} })).toEqual({ a: {
-		b: 1,
-		c: 2
-	} });
-	expect(applyDefaults(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);
 }
@@ -949,10 +607,7 @@ async function getConfigOverrideErrors(schema, configOverride, options = {}) {
 				return yupUnion(...nonObjectSchemas.map(([index, s]) => getRestrictedSchema(path + `|variant-${index}|`, s)), ...objectSchemas.length > 0 ? [getRestrictedSchema(path + (nonObjectSchemas.length > 0 ? `|variant|` : ""), mergedObjectSchema)] : []);
 			}
 			case "record": return yupRecord(getRestrictedSchema(path + ".key", schemaInfo.keySchema), getRestrictedSchema(path + ".value", schemaInfo.valueSchema));
-			case "object": {
-				const objectSchema = schema;
-				return yupObject(Object.fromEntries(Object.entries(objectSchema.fields).map(([key, value]) => [key, getRestrictedSchema(path + "." + key, value)])));
-			}
+			case "object": return yupObject(Object.fromEntries(Object.entries(schema.fields).map(([key, value]) => [key, getRestrictedSchema(path + "." + key, value)])));
 			case "never": return yupNever();
 			default: throw new HexclaveAssertionError(`Unknown schema info at path ${path}: ${JSON.stringify(schemaInfo)}`, {
 				schemaInfo,
@@ -1069,7 +724,7 @@ typeAssertExtends()();
 typeAssert()();
 typeAssert()();
 typeAssertExtends()();
-
 //#endregion
 export { applyBranchDefaults, applyEnvironmentDefaults, applyOrganizationDefaults, applyProjectDefaults, assertNoConfigOverrideErrors, branchConfigSchema, branchPaymentsSchema, configLevels, environmentConfigSchema, getConfigOverrideErrors, getIncompleteConfigWarnings, migrateConfigOverride, organizationConfigSchema, projectConfigSchema, sanitizeBranchConfig, sanitizeEnvironmentConfig, sanitizeOrganizationConfig, sanitizeProjectConfig };
+
 //# sourceMappingURL=schema.js.map