@notionhq/workers 0.5.0 → 0.7.0

package/src/json-schema.ts

@@ -45,16 +45,18 @@ interface ForbiddenCompositionKeywords {
 
 // ---- Individual schema definitions ----
 
-export interface JSONSchemaStringDef<T extends string = string>
-	extends ForbiddenCompositionKeywords {
+export interface JSONSchemaStringDef<
+	T extends string = string,
+> extends ForbiddenCompositionKeywords {
 	type: "string";
 	description?: string;
 	format?: JSONSchemaStringFormat;
 	enum?: readonly T[];
 }
 
-export interface JSONSchemaNumberDef<T extends number = number>
-	extends ForbiddenCompositionKeywords {
+export interface JSONSchemaNumberDef<
+	T extends number = number,
+> extends ForbiddenCompositionKeywords {
 	type: "number" | "integer";
 	description?: string;
 	enum?: readonly T[];
@@ -70,8 +72,7 @@ export interface JSONSchemaNullDef extends ForbiddenCompositionKeywords {
 	description?: string;
 }
 
-export interface JSONSchemaArrayDef<E = unknown>
-	extends ForbiddenCompositionKeywords {
+export interface JSONSchemaArrayDef<E = unknown> extends ForbiddenCompositionKeywords {
 	type: "array";
 	description?: string;
 	items: JSONSchema<E>;

package/src/pacer.test.ts

@@ -83,9 +83,7 @@ describe("pacerWait", () => {
 	it("throws when pacer key not found in runtime context", async () => {
 		setPacerState({ pacers: {} });
 
-		await expect(pacerWait("unknown")).rejects.toThrow(
-			'Pacer "unknown" not found',
-		);
+		await expect(pacerWait("unknown")).rejects.toThrow('Pacer "unknown" not found');
 	});
 
 	it("preserves allowedRequests and intervalMs across calls", async () => {

package/src/pacer_internal.ts

@@ -39,11 +39,7 @@ export function initPacerState(
 	declarations?: readonly PacerDeclaration[],
 ): void {
 	const pacers = runtimePacers ?? {};
-	if (
-		Object.keys(pacers).length === 0 &&
-		declarations &&
-		declarations.length > 0
-	) {
+	if (Object.keys(pacers).length === 0 && declarations && declarations.length > 0) {
 		const localPacers: Record<string, PacerEntry> = {};
 		for (const decl of declarations) {
 			localPacers[decl.key] = {

package/src/schema-builder.test.ts

@@ -1,11 +1,7 @@
 import { describe, expect, it } from "vitest";
+
 import type { JSONSchema } from "./json-schema.js";
-import {
-	getSchema,
-	type Infer,
-	j,
-	type SchemaBuilder,
-} from "./schema-builder.js";
+import { getSchema, type Infer, j, type SchemaBuilder } from "./schema-builder.js";
 
 // ---------------------------------------------------------------------------
 // 1. Primitives
@@ -188,9 +184,7 @@ describe("json-schema-builder — array", () => {
 	});
 
 	it("array of objects", () => {
-		const schema = getSchema(
-			j.array(j.object({ name: j.string(), age: j.number() })),
-		);
+		const schema = getSchema(j.array(j.object({ name: j.string(), age: j.number() })));
 		expect(schema).toEqual({
 			type: "array",
 			items: {
@@ -351,9 +345,7 @@ describe("json-schema-builder — anyOf", () => {
 	});
 
 	it("anyOf with description", () => {
-		expect(
-			getSchema(j.anyOf(j.string(), j.number()).describe("string or number")),
-		).toEqual({
+		expect(getSchema(j.anyOf(j.string(), j.number()).describe("string or number"))).toEqual({
 			anyOf: [{ type: "string" }, { type: "number" }],
 			description: "string or number",
 		});
@@ -463,12 +455,8 @@ describe("json-schema-builder — discriminated unions", () => {
 
 	it("discriminated union with descriptions on individual variants", () => {
 		const schema = j.anyOf(
-			j
-				.object({ type: j.enum("text"), value: j.string() })
-				.describe("A text node"),
-			j
-				.object({ type: j.enum("image"), url: j.string() })
-				.describe("An image node"),
+			j.object({ type: j.enum("text"), value: j.string() }).describe("A text node"),
+			j.object({ type: j.enum("image"), url: j.string() }).describe("An image node"),
 		);
 
 		const raw = getSchema(schema) as unknown as {
@@ -497,9 +485,7 @@ describe("json-schema-builder — discriminated unions", () => {
 		expect(raw.properties.content.anyOf).toHaveLength(2);
 
 		// The content field is in required
-		expect(
-			(getSchema(schema) as unknown as Record<string, unknown>).required,
-		).toContain("content");
+		expect((getSchema(schema) as unknown as Record<string, unknown>).required).toContain("content");
 	});
 
 	it("nullable discriminated union", () => {
@@ -614,15 +600,7 @@ describe("json-schema-builder — integration", () => {
 				},
 				createdAt: { type: "string", format: "date-time" },
 			},
-			required: [
-				"foo",
-				"bar",
-				"count",
-				"tags",
-				"address",
-				"nickname",
-				"createdAt",
-			],
+			required: ["foo", "bar", "count", "tags", "address", "nickname", "createdAt"],
 			additionalProperties: false,
 		});
 	});
@@ -634,9 +612,7 @@ describe("json-schema-builder — integration", () => {
 
 describe("json-schema-builder — constraint enforcement", () => {
 	it("object always has required matching properties keys", () => {
-		const schema = getSchema(
-			j.object({ x: j.number(), y: j.string(), z: j.boolean() }),
-		);
+		const schema = getSchema(j.object({ x: j.number(), y: j.string(), z: j.boolean() }));
 		const raw = schema as unknown as Record<string, unknown>;
 		expect(raw.required).toEqual(["x", "y", "z"]);
 		expect(raw.additionalProperties).toBe(false);
@@ -669,8 +645,7 @@ describe("json-schema-builder — constraint enforcement", () => {
 			}),
 		);
 		const raw = schema as unknown as Record<string, unknown>;
-		const outer = (raw as { properties: { outer: Record<string, unknown> } })
-			.properties.outer;
+		const outer = (raw as { properties: { outer: Record<string, unknown> } }).properties.outer;
 		expect(outer.required).toEqual(["inner"]);
 		expect(outer.additionalProperties).toBe(false);
 	});

package/src/schema-builder.ts

@@ -47,12 +47,8 @@ function makeBuilder<T>(schema: AnyJSONSchema): SchemaBuilder<T> {
 			return makeBuilder<T>({ ...schema, description: text });
 		},
 		nullable() {
-			const { description: desc, ...rest } = schema as unknown as Record<
-				string,
-				unknown
-			>;
-			const inner =
-				desc !== undefined ? (rest as unknown as AnyJSONSchema) : schema;
+			const { description: desc, ...rest } = schema as unknown as Record<string, unknown>;
+			const inner = desc !== undefined ? (rest as unknown as AnyJSONSchema) : schema;
 			const wrapper: Record<string, unknown> = {
 				anyOf: [inner, { type: "null" }],
 			};
@@ -82,15 +78,9 @@ export function boolean(): SchemaBuilder<boolean> {
 
 // ---- Enum ----
 
-function enumBuilder<T extends string>(
-	...values: readonly T[]
-): SchemaBuilder<T>;
-function enumBuilder<T extends number>(
-	...values: readonly T[]
-): SchemaBuilder<T>;
-function enumBuilder(
-	...values: readonly (string | number)[]
-): SchemaBuilder<unknown> {
+function enumBuilder<T extends string>(...values: readonly T[]): SchemaBuilder<T>;
+function enumBuilder<T extends number>(...values: readonly T[]): SchemaBuilder<T>;
+function enumBuilder(...values: readonly (string | number)[]): SchemaBuilder<unknown> {
 	const type = typeof values[0] === "string" ? "string" : "number";
 	return makeBuilder({ type, enum: values } as AnyJSONSchema);
 }
@@ -155,7 +145,6 @@ export function object<P extends Record<string, SchemaBuilder<unknown>>>(
 	const schemaProps: Record<string, AnyJSONSchema> = {};
 	const keys = Object.keys(properties);
 	for (const key of keys) {
-		// biome-ignore lint/style/noNonNullAssertion: key comes from Object.keys(properties)
 		schemaProps[key] = getSchema(properties[key]!);
 	}
 	return makeBuilder({

package/src/schema.ts

@@ -1,10 +1,4 @@
-import type {
-	DateFormat,
-	Icon,
-	NumberFormat,
-	SelectOption,
-	StatusGroup,
-} from "./types.js";
+import type { DateFormat, Icon, NumberFormat, SelectOption, StatusGroup } from "./types.js";
 
 /**
  * Supported property types for sync schemas.
@@ -182,9 +176,7 @@ export function multiSelect(options: SelectOption[]): PropertyConfiguration {
 /**
  * Creates a status property definition with groups.
  */
-export function status(config: {
-	groups: StatusGroup[];
-}): PropertyConfiguration {
+export function status(config: { groups: StatusGroup[] }): PropertyConfiguration {
 	return { type: "status", groups: config.groups };
 }
 

package/src/types.ts

@@ -118,13 +118,7 @@ export type NumberFormat =
 /**
  * Date format types
  */
-export type DateFormat =
-	| "relative"
-	| "MM/DD/YYYY"
-	| "DD/MM/YYYY"
-	| "YYYY/MM/DD"
-	| "ll"
-	| "MMM d";
+export type DateFormat = "relative" | "MM/DD/YYYY" | "DD/MM/YYYY" | "YYYY/MM/DD" | "ll" | "MMM d";
 
 import type { NoticonName } from "./icon-names.js";
 

package/src/worker.ts

@@ -27,10 +27,7 @@ import type {
 	WebhookConfiguration,
 	WebhookEvent,
 } from "./capabilities/webhook.js";
-import {
-	createWebhookCapability,
-	WebhookVerificationError,
-} from "./capabilities/webhook.js";
+import { createWebhookCapability, WebhookVerificationError } from "./capabilities/webhook.js";
 import type {
 	WorkflowCapability,
 	WorkflowConfiguration,
@@ -68,7 +65,6 @@ export { WebhookVerificationError };
 type Capability =
 	| SyncCapability
 	| AiConnectorCapability
-	// biome-ignore lint/suspicious/noExplicitAny: tool capabilities are generic over arbitrary input/output payloads.
 	| ToolCapability<any, any>
 	| AutomationCapability
 	| WorkflowCapability
@@ -92,19 +88,13 @@ export type CapabilityType = Capability["_tag"];
 // incoming context matches the capability's declared input.
 
 /** A tool capability as stored: its input/output types are erased. */
-type StoredToolCapability = Omit<
-	Extract<Capability, { _tag: "tool" }>,
-	"handler"
-> & {
+type StoredToolCapability = Omit<Extract<Capability, { _tag: "tool" }>, "handler"> & {
 	handler: (input: never, options?: HandlerOptions) => Promise<unknown>;
 };
 
 /** A workflow capability as stored: its event type is erased. */
 type StoredWorkflowCapability = Omit<WorkflowCapability, "handler"> & {
-	handler: (
-		event: never,
-		options?: HandlerOptions,
-	) => Promise<{ status: "success" } | undefined>;
+	handler: (event: never, options?: HandlerOptions) => Promise<{ status: "success" } | undefined>;
 };
 
 /** How `Worker` stores registered capabilities internally. */
@@ -148,10 +138,7 @@ export type ManagedDatabaseConfig<PK extends string, S extends Schema<PK>> = {
  * Configuration union for all database types.
  * Currently only `"managed"` is supported.
  */
-export type DatabaseConfig<
-	PK extends string,
-	S extends Schema<PK>,
-> = ManagedDatabaseConfig<PK, S>;
+export type DatabaseConfig<PK extends string, S extends Schema<PK>> = ManagedDatabaseConfig<PK, S>;
 
 /**
  * An opaque handle returned by `worker.database()`. Pass this to
@@ -495,10 +482,7 @@ export class Worker {
 	 * @param config - The automation configuration.
 	 * @returns The capability object.
 	 */
-	automation(
-		key: string,
-		config: AutomationConfiguration,
-	): AutomationCapability {
+	automation(key: string, config: AutomationConfiguration): AutomationCapability {
 		this.#validateUniqueKey(key);
 		const capability = createAutomationCapability(key, config);
 		this.#capabilities.set(key, capability);
@@ -532,9 +516,7 @@ export class Worker {
 	 * @param config - The workflow configuration.
 	 * @returns The capability object.
 	 */
-	workflow<
-		const TTriggers extends readonly [WorkflowTrigger, ...WorkflowTrigger[]],
-	>(
+	workflow<const TTriggers extends readonly [WorkflowTrigger, ...WorkflowTrigger[]]>(
 		key: string,
 		config: WorkflowConfiguration<TTriggers>,
 	): WorkflowCapability<TTriggers> {
@@ -655,11 +637,7 @@ export class Worker {
 	 * @param options - Additional options for execution (e.g. for testing).
 	 * @returns The result of the capability execution.
 	 */
-	async run(
-		key: string,
-		context: unknown,
-		options: HandlerOptions = {},
-	): Promise<unknown> {
+	async run(key: string, context: unknown, options: HandlerOptions = {}): Promise<unknown> {
 		const capability = this.#capabilities.get(key);
 
 		if (!capability) {
@@ -687,11 +665,7 @@ export class Worker {
 		if (!key || typeof key !== "string") {
 			throw new Error("Capability key must be a non-empty string");
 		}
-		if (
-			this.#capabilities.has(key) ||
-			this.#databases.has(key) ||
-			this.#pacers.has(key)
-		) {
+		if (this.#capabilities.has(key) || this.#databases.has(key) || this.#pacers.has(key)) {
 			throw new Error(`Worker item with key "${key}" already registered`);
 		}
 	}