@btst/stack 5.1.0 → 5.2.0

package/src/plugins/feature-flags/schemas.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+
+/** Stable URL-safe key; reserved JavaScript property names cannot become bulk keys. */
+export const flagKeySchema = z
+	.string()
+	.min(1)
+	.max(100)
+	.regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
+	.refine(
+		(key) => !["new", "constructor", "prototype"].includes(key),
+		"Choose another flag key",
+	);
+export const flagContextSchema = z.object({
+	userId: z.string().min(1).max(256).optional(),
+	sessionId: z.string().min(1).max(256).optional(),
+	email: z.email().max(320).optional(),
+	tags: z.array(z.string().min(1).max(100)).max(100).optional(),
+});
+export const segmentRuleSchema = z
+	.object({
+		field: z.enum(["userId", "email", "tags"]),
+		operator: z.enum(["equals", "contains", "in"]),
+		value: z.union([
+			z.string().min(1).max(320),
+			z.array(z.string().min(1).max(320)).min(1).max(100),
+		]),
+	})
+	.superRefine((rule, ctx) => {
+		if (
+			rule.operator === "in"
+				? !Array.isArray(rule.value)
+				: typeof rule.value !== "string"
+		)
+			ctx.addIssue({
+				code: "custom",
+				path: ["value"],
+				message:
+					rule.operator === "in"
+						? "Provide a list of values"
+						: "Provide one value",
+			});
+		if (
+			(rule.field === "tags" && rule.operator === "equals") ||
+			(rule.field !== "tags" && rule.operator === "contains")
+		)
+			ctx.addIssue({
+				code: "custom",
+				path: ["operator"],
+				message:
+					"Use equals or in for users and emails; contains or in for tags",
+			});
+	});
+const flagFields = z.object({
+	name: z.string().trim().min(1).max(200),
+	description: z.string().max(2000).nullable().optional(),
+	type: z.enum(["boolean", "rollout", "segment"]).default("boolean"),
+	enabled: z.boolean().default(false),
+	rolloutPct: z.number().finite().min(0).max(100).nullable().optional(),
+	segments: z.array(segmentRuleSchema).max(50).default([]),
+	tags: z.array(z.string().trim().min(1).max(100)).max(50).default([]),
+});
+export const flagConfigurationSchema = flagFields.superRefine((flag, ctx) => {
+	if (flag.type === "rollout" && flag.rolloutPct == null)
+		ctx.addIssue({
+			code: "custom",
+			path: ["rolloutPct"],
+			message: "A rollout percentage is required",
+		});
+	if (flag.type === "segment" && !flag.segments.length)
+		ctx.addIssue({
+			code: "custom",
+			path: ["segments"],
+			message: "Add at least one targeting rule",
+		});
+});
+export const createFlagSchema = flagFields
+	.extend({ key: flagKeySchema })
+	.superRefine((flag, ctx) => {
+		const parsed = flagConfigurationSchema.safeParse(flag);
+		if (!parsed.success)
+			for (const issue of parsed.error.issues)
+				ctx.addIssue({
+					code: "custom",
+					path: issue.path,
+					message: issue.message,
+				});
+	});
+export const updateFlagSchema = z
+	.object({
+		...flagFields.shape,
+		type: flagFields.shape.type.removeDefault(),
+		enabled: flagFields.shape.enabled.removeDefault(),
+		segments: flagFields.shape.segments.removeDefault(),
+		tags: flagFields.shape.tags.removeDefault(),
+	})
+	.partial()
+	.strict();
+export const keySchema = z.object({ key: flagKeySchema });
+export const listFlagsSchema = z.object({
+	includeArchived: z
+		.union([
+			z.boolean(),
+			z.enum(["true", "false"]).transform((value) => value === "true"),
+		])
+		.default(false),
+});
+export const evaluateSchema = keySchema.extend({
+	context: flagContextSchema.optional(),
+});
+export const evaluateAllSchema = z.object({
+	context: flagContextSchema.optional(),
+});
+/** Bounded base64 UTF-8 JSON, accepted by both evaluation endpoints. */
+export const evaluationQuerySchema = z.object({
+	context: z.string().max(32768).optional(),
+});
+
+export type CreateFlagInput = z.input<typeof createFlagSchema>;
+export type UpdateFlagInput = z.input<typeof updateFlagSchema>;

package/src/plugins/feature-flags/style.css

@@ -0,0 +1,2 @@
+@import "./client.css";
+@source "./client/**/*.{ts,tsx}";

package/src/plugins/feature-flags/types.ts

@@ -0,0 +1,53 @@
+/** Inputs used for targeting and deterministic rollout assignment. */
+export type FlagContext = {
+	userId?: string;
+	sessionId?: string;
+	email?: string;
+	tags?: string[];
+};
+
+/** Rules are combined with AND. Values within an `in` rule are combined with OR. */
+export type SegmentRule = {
+	field: "userId" | "email" | "tags";
+	operator: "equals" | "contains" | "in";
+	value: string | string[];
+};
+
+/** Transport-safe flag definition. Archived flags always evaluate to false. */
+export type FeatureFlag = {
+	id: string;
+	key: string;
+	name: string;
+	description: string | null;
+	type: "boolean" | "rollout" | "segment";
+	enabled: boolean;
+	rolloutPct: number | null;
+	segments: SegmentRule[];
+	tags: string[];
+	archivedAt: string | null;
+	createdAt: string;
+	updatedAt: string;
+};
+
+/** Database representation; arrays are serialized JSON. */
+export type FlagRecord = Omit<
+	FeatureFlag,
+	"segments" | "tags" | "archivedAt" | "createdAt" | "updatedAt"
+> & {
+	segments: string;
+	tags: string;
+	archivedAt: Date | null;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+/** Latest evaluation retained in the flag's bounded in-process history. */
+export type FlagEvaluation = {
+	id: string;
+	flagKey: string;
+	result: boolean;
+	context: FlagContext;
+	timestamp: string;
+};
+
+export type { CreateFlagInput, UpdateFlagInput } from "./schemas";

package/src/plugins/job-board/__tests__/date-field.test.tsx

@@ -0,0 +1,156 @@
+// @vitest-environment jsdom
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import AutoFormDate from "@workspace/ui/components/auto-form/fields/date";
+import type { AutoFormInputComponentProps } from "@workspace/ui/components/auto-form/types";
+import {
+	formSchemaToZod,
+	zodToFormSchema,
+} from "@workspace/ui/lib/schema-converter";
+import { jobSchema } from "../schemas";
+
+(
+	globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+vi.mock("@workspace/ui/components/date-picker", () => ({
+	DatePicker: ({
+		date,
+		setDate,
+	}: {
+		date?: Date;
+		setDate: (value?: Date) => void;
+	}) => (
+		<>
+			<button
+				type="button"
+				data-day={date?.getDate()}
+				onClick={() => setDate(new Date(2030, 0, 7))}
+			>
+				Choose January 7
+			</button>
+			<button type="button" data-clear onClick={() => setDate(undefined)}>
+				Clear date
+			</button>
+		</>
+	),
+}));
+vi.mock("@workspace/ui/components/form", () => ({
+	FormControl: ({ children }: { children: React.ReactNode }) => children,
+	FormItem: ({ children }: { children: React.ReactNode }) => children,
+	FormMessage: () => null,
+}));
+vi.mock("@workspace/ui/components/auto-form/common/label", () => ({
+	default: () => null,
+}));
+vi.mock("@workspace/ui/components/auto-form/common/tooltip", () => ({
+	default: () => null,
+}));
+
+let container: HTMLDivElement;
+let root: Root;
+
+beforeEach(() => {
+	container = document.createElement("div");
+	document.body.appendChild(container);
+	root = createRoot(container);
+});
+afterEach(async () => {
+	await act(async () => root.unmount());
+	container.remove();
+	vi.unstubAllEnvs();
+});
+
+async function renderDate(schema: z.ZodType, value?: string) {
+	const onChange = vi.fn();
+	const props: AutoFormInputComponentProps = {
+		label: "Closing date",
+		isRequired: false,
+		zodItem: schema,
+		fieldConfigItem: {},
+		fieldProps: {},
+		zodInputProps: {},
+		field: {
+			name: "closingDate",
+			value,
+			onChange,
+			onBlur: vi.fn(),
+			ref: vi.fn(),
+		},
+	};
+	await act(async () => root.render(<AutoFormDate {...props} />));
+	return { onChange, button: container.querySelector("button")! };
+}
+
+describe("CMS date-only fields", () => {
+	it("preserves date-only selection and null clearing after the CMS schema storage roundtrip", async () => {
+		vi.stubEnv("TZ", "Asia/Tokyo");
+		const storedSchema = JSON.parse(JSON.stringify(zodToFormSchema(jobSchema)));
+		const reconstructed = formSchemaToZod(storedSchema) as z.ZodObject<{
+			closingDate: z.ZodType;
+		}>;
+		const closingDate = reconstructed.shape.closingDate!;
+		const { onChange, button } = await renderDate(closingDate);
+		await act(async () => button.click());
+		expect(onChange).toHaveBeenLastCalledWith("2030-01-07");
+		expect(closingDate.safeParse(onChange.mock.calls[0]?.[0]).success).toBe(
+			true,
+		);
+		await act(async () =>
+			container.querySelector<HTMLButtonElement>("[data-clear]")!.click(),
+		);
+		expect(onChange).toHaveBeenLastCalledWith(null);
+		expect(closingDate.safeParse(null).success).toBe(true);
+	});
+	it.each([
+		["Zod ISO date", z.iso.date().optional()],
+		["JSON Schema date", z.fromJSONSchema({ type: "string", format: "date" })],
+	] as const)(
+		"preserves the selected Tokyo calendar day for %s",
+		async (_name, schema) => {
+			vi.stubEnv("TZ", "Asia/Tokyo");
+			const { onChange, button } = await renderDate(schema);
+			await act(async () => button.click());
+			expect(onChange).toHaveBeenCalledWith("2030-01-07");
+		},
+	);
+
+	it("loads a stored calendar day in Los Angeles without shifting to the previous day", async () => {
+		vi.stubEnv("TZ", "America/Los_Angeles");
+		const { button } = await renderDate(z.iso.date(), "2030-01-07");
+		expect(button.dataset.day).toBe("7");
+	});
+
+	it("retains ISO timestamps for date-time schemas", async () => {
+		vi.stubEnv("TZ", "Asia/Tokyo");
+		const { onChange, button } = await renderDate(z.iso.datetime());
+		await act(async () => button.click());
+		expect(onChange).toHaveBeenCalledWith("2030-01-06T15:00:00.000Z");
+	});
+
+	it("retains Date objects for z.date schemas", async () => {
+		vi.stubEnv("TZ", "Asia/Tokyo");
+		const { onChange, button } = await renderDate(z.date());
+		await act(async () => button.click());
+		expect(onChange.mock.calls[0]?.[0]).toBeInstanceOf(Date);
+		expect(onChange.mock.calls[0]?.[0].getDate()).toBe(7);
+	});
+
+	it.each([
+		["nullable date-only", z.iso.date().nullable().optional(), null],
+		["optional date-only", z.iso.date().optional(), undefined],
+		["nullable date-time", z.iso.datetime().nullable().optional(), undefined],
+		["nullable Date object", z.date().nullable().optional(), undefined],
+	] as const)(
+		"clears %s fields without changing other date contracts",
+		async (_name, schema, expected) => {
+			const { onChange } = await renderDate(schema);
+			await act(async () =>
+				container.querySelector<HTMLButtonElement>("[data-clear]")!.click(),
+			);
+			expect(onChange).toHaveBeenCalledWith(expected);
+		},
+	);
+});

package/src/plugins/job-board/__tests__/department-url.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { decodeJobDepartment, encodeJobDepartment } from "../utils";
+
+describe("department URL identifiers", () => {
+	it.each([
+		"Engineering",
+		"Sales / Marketing ~ 50%",
+		"研究開発",
+		"a~2Fb",
+		"100% / Remote",
+	])(
+		"preserves %s through a host router's early URL decoding",
+		(department) => {
+			const identifier = encodeJobDepartment(department);
+			expect(identifier).not.toMatch(/[%/]/);
+			expect(decodeJobDepartment(decodeURIComponent(identifier))).toBe(
+				department,
+			);
+		},
+	);
+	it("keeps ordinary department names readable", () => {
+		expect(encodeJobDepartment("Engineering")).toBe("Engineering");
+	});
+	it.each([
+		[".", "~2E"],
+		["..", "~2E~2E"],
+	])("preserves the %s department as a URL segment", (department, expected) => {
+		const identifier = encodeJobDepartment(department);
+		expect(identifier).toBe(expected);
+		expect(
+			new URL(`/jobs/department/${identifier}`, "https://example.com").pathname,
+		).toBe(`/jobs/department/${expected}`);
+		expect(decodeJobDepartment(decodeURIComponent(identifier))).toBe(
+			department,
+		);
+	});
+	it.each(["broken~", "broken~QQ", "~FF", "50%"])(
+		"rejects malformed identifiers without throwing: %s",
+		(identifier) => {
+			expect(decodeJobDepartment(identifier)).toBeUndefined();
+		},
+	);
+});