@useairfoil/connector-kit 0.6.0 → 0.7.0

package/dist/table-CxM09xf7.mjs

@@ -0,0 +1,307 @@
+import { Data, Effect, Schema } from "effect";
+//#region src/iceberg/error.ts
+/** A schema could not be turned into an Iceberg table. */
+var IcebergSchemaError = class extends Data.TaggedError("IcebergSchemaError") {};
+//#endregion
+//#region src/iceberg/table.ts
+const anonymousDeclaration = "Schemas without a name, such as Schema.Class, do not work here; use Schema.Struct";
+var CompilationFailure = class extends Error {
+	path;
+	constructor(path, message) {
+		super(message);
+		this.path = path;
+	}
+};
+const fail = (path, message) => {
+	throw new CompilationFailure(path, message);
+};
+const propertyPath = (path, name) => /^[A-Za-z_$][\w$]*$/.test(name) ? `${path}.${name}` : `${path}[${JSON.stringify(name)}]`;
+/** Reads annotations the way Effect does: if there are checks, the last one wins. */
+const resolveAnnotations = (representation) => {
+	const lastCheck = representation.checks.at(-1);
+	return lastCheck === void 0 ? representation.annotations : lastCheck.annotations;
+};
+const description = (annotations) => {
+	const value = annotations?.description;
+	return typeof value === "string" ? value : void 0;
+};
+/** @internal */
+const checkHasRepresentation = (checks, id) => checks.some((check) => check.representation?.id === id || check._tag === "FilterGroup" && checkHasRepresentation(check.checks, id));
+const isAnonymousDeclaration = (representation) => representation._tag === "Declaration" && representation.representation?.id === void 0;
+const literalType = (literal, path) => {
+	switch (typeof literal) {
+		case "string": return "string";
+		case "boolean": return "boolean";
+		case "number": return Number.isFinite(literal) ? "double" : fail(path, "A number literal must be a real number, not Infinity or NaN");
+		case "bigint": return "long";
+		default: return fail(path, `A ${typeof literal} literal does not work here`);
+	}
+};
+const identifierId = (fields, name) => {
+	const path = propertyPath("$", name);
+	const field = fields.find((candidate) => candidate.name === name);
+	if (!field) return fail(path, "Iceberg.identifier names a field that does not exist");
+	if (!field.required) return fail(path, "An identifier field cannot be optional or null");
+	if (typeof field.type !== "string" || field.type === "float" || field.type === "double") return fail(path, "An identifier field must be a primitive type other than float or double");
+	return field.id;
+};
+const assertNever = (_representation, path) => fail(path, "This kind of schema does not work here");
+var Compiler = class {
+	references;
+	#activeObjects = /* @__PURE__ */ new Set();
+	#activeReferences = /* @__PURE__ */ new Set();
+	#activeSuspends = /* @__PURE__ */ new Set();
+	#nextId = 0;
+	constructor(references) {
+		this.references = references;
+	}
+	compile(root) {
+		return this.#withReference(root, "$", (representation) => {
+			if (isAnonymousDeclaration(representation)) return fail("$", anonymousDeclaration);
+			if (representation._tag !== "Objects") return fail("$", "The top level of a table must be a Schema.Struct");
+			const annotations = resolveAnnotations(representation);
+			const fields = this.#compileFields(representation, "$");
+			const identifierIds = (annotations?.icebergIdentifierFields ?? []).map((name) => identifierId(fields, name));
+			return {
+				schema: identifierIds.length === 0 ? {
+					type: "struct",
+					fields
+				} : {
+					type: "struct",
+					fields: fields.map((field) => ({
+						...field,
+						required: identifierIds.includes(field.id)
+					})),
+					"identifier-field-ids": identifierIds
+				},
+				description: description(annotations)
+			};
+		});
+	}
+	#withReference(representation, path, compile) {
+		if (representation._tag !== "Reference") return compile(representation);
+		const reference = representation.$ref;
+		const resolved = this.references[reference];
+		if (resolved === void 0) return fail(path, `Cannot find the schema named ${reference}`);
+		if (this.#activeReferences.has(reference)) return fail(path, "Iceberg cannot store a schema that contains itself");
+		this.#activeReferences.add(reference);
+		try {
+			return this.#withReference(resolved, path, compile);
+		} finally {
+			this.#activeReferences.delete(reference);
+		}
+	}
+	#checkRecursion(representation, path) {
+		if (representation._tag === "Reference" && this.#activeReferences.has(representation.$ref)) fail(path, "Iceberg cannot store a schema that contains itself");
+	}
+	#compileFields(representation, path) {
+		if (representation.indexSignatures.length > 0) return fail(path, "Schema.Record does not work here; name the keys with Schema.Struct, or store it as a JSON string");
+		return representation.propertySignatures.map((property) => {
+			if (typeof property.name !== "string") return fail(propertyPath(path, String(property.name)), "Iceberg field names must be strings");
+			const fieldPath = propertyPath(path, property.name);
+			this.#checkRecursion(property.type, fieldPath);
+			const id = ++this.#nextId;
+			const compiled = this.#compileType(property.type, fieldPath);
+			const fieldDescription = description(property.annotations);
+			return {
+				id,
+				name: property.name,
+				type: compiled.type,
+				required: !property.isOptional && !compiled.nullable,
+				...fieldDescription === void 0 ? {} : { doc: fieldDescription }
+			};
+		});
+	}
+	#compileType(representation, path) {
+		if (representation._tag === "Reference") return this.#withReference(representation, path, (resolved) => this.#compileType(resolved, path));
+		switch (representation._tag) {
+			case "String": return {
+				type: "string",
+				nullable: false
+			};
+			case "Boolean": return {
+				type: "boolean",
+				nullable: false
+			};
+			case "BigInt": return {
+				type: "long",
+				nullable: false
+			};
+			case "Number": return checkHasRepresentation(representation.checks, "effect/schema/isFinite") || checkHasRepresentation(representation.checks, "effect/schema/isInt") ? {
+				type: "double",
+				nullable: false
+			} : fail(path, "Plain Schema.Number does not work here; use Schema.Finite or Schema.Int");
+			case "Literal": return {
+				type: literalType(representation.literal, path),
+				nullable: false
+			};
+			case "Objects":
+				if (this.#activeObjects.has(representation)) return fail(path, "Iceberg cannot store a schema that contains itself");
+				this.#activeObjects.add(representation);
+				try {
+					return {
+						type: {
+							type: "struct",
+							fields: this.#compileFields(representation, path)
+						},
+						nullable: false
+					};
+				} finally {
+					this.#activeObjects.delete(representation);
+				}
+			case "Arrays": return this.#compileArray(representation, path);
+			case "Declaration": return this.#compileDeclaration(representation, path);
+			case "Union": return this.#compileUnion(representation, path);
+			case "Suspend":
+				if (this.#activeSuspends.has(representation)) return fail(path, "Iceberg cannot store a schema that contains itself");
+				this.#activeSuspends.add(representation);
+				try {
+					return this.#compileType(representation.thunk, path);
+				} finally {
+					this.#activeSuspends.delete(representation);
+				}
+			case "Null":
+			case "Undefined": return fail(path, "A field cannot contain only null or undefined");
+			case "Any":
+			case "Unknown":
+			case "ObjectKeyword":
+			case "Symbol":
+			case "UniqueSymbol":
+			case "Void":
+			case "Never":
+			case "Enum":
+			case "TemplateLiteral": return fail(path, `A ${representation._tag} schema does not work here`);
+			default: return assertNever(representation, path);
+		}
+	}
+	#compileArray(representation, path) {
+		if (representation.elements.length > 0 || representation.rest.length !== 1) return fail(path, "A tuple does not work here; use a Schema.Array where every item has the same type");
+		const elementPath = `${path}.element`;
+		const elementRepresentation = representation.rest[0];
+		const elementId = ++this.#nextId;
+		const compiled = this.#compileType(elementRepresentation, elementPath);
+		return {
+			type: {
+				type: "list",
+				"element-id": elementId,
+				element: compiled.type,
+				"element-required": !compiled.nullable
+			},
+			nullable: false
+		};
+	}
+	#compileDeclaration(representation, path) {
+		const id = representation.representation?.id;
+		switch (id) {
+			case "effect/schema/Date": return {
+				type: "timestamptz",
+				nullable: false
+			};
+			case "effect/schema/Uint8Array": return {
+				type: "binary",
+				nullable: false
+			};
+			case "effect/schema/ReadonlyMap": return this.#compileMap(representation, path);
+			case void 0: return fail(path, anonymousDeclaration);
+			default: return fail(path, `The ${id} schema does not work here`);
+		}
+	}
+	#compileMap(representation, path) {
+		if (representation.typeParameters.length !== 2) return fail(path, "ReadonlyMap needs one key schema and one value schema");
+		const keyPath = `${path}.key`;
+		const valuePath = `${path}.value`;
+		const keyRepresentation = representation.typeParameters[0];
+		const valueRepresentation = representation.typeParameters[1];
+		const keyId = ++this.#nextId;
+		const compiledKey = this.#compileType(keyRepresentation, keyPath);
+		if (compiledKey.nullable) return fail(keyPath, "Map keys cannot be null");
+		const valueId = ++this.#nextId;
+		const compiledValue = this.#compileType(valueRepresentation, valuePath);
+		return {
+			type: {
+				type: "map",
+				"key-id": keyId,
+				key: compiledKey.type,
+				"value-id": valueId,
+				value: compiledValue.type,
+				"value-required": !compiledValue.nullable
+			},
+			nullable: false
+		};
+	}
+	#compileUnion(representation, path) {
+		let nullable = false;
+		const concrete = [];
+		for (const member of representation.types) if (member._tag === "Null" || member._tag === "Undefined") nullable = true;
+		else concrete.push(member);
+		if (concrete.length === 0) return fail(path, "A field cannot contain only null or undefined");
+		if (concrete.length === 1) {
+			const compiled = this.#compileType(concrete[0], path);
+			return {
+				type: compiled.type,
+				nullable: nullable || compiled.nullable
+			};
+		}
+		if (!concrete.every((member) => member._tag === "Literal")) return fail(path, "A union only works when every member is a literal");
+		const first = literalType(concrete[0].literal, path);
+		for (const member of concrete.slice(1)) if (literalType(member.literal, path) !== first) return fail(path, "Every literal in a union must be the same type");
+		return {
+			type: first,
+			nullable
+		};
+	}
+};
+const compileTable = (schema) => Effect.try({
+	try: () => {
+		const document = Schema.toRepresentation(Schema.toType(schema));
+		return new Compiler(document.references).compile(document.representation);
+	},
+	catch: (cause) => cause instanceof CompilationFailure ? new IcebergSchemaError({
+		path: cause.path,
+		message: cause.message,
+		cause
+	}) : new IcebergSchemaError({
+		path: "$",
+		message: cause instanceof Error ? cause.message : String(cause),
+		cause
+	})
+});
+const makeCreateRequest = (table, options) => ({
+	name: options.name,
+	schema: table.schema,
+	...options.location === void 0 ? {} : { location: options.location },
+	properties: {
+		...table.description === void 0 ? {} : { comment: table.description },
+		...options.properties,
+		"format-version": "3"
+	}
+});
+/**
+* Builds a REST create-table request from an Effect schema.
+* The catalog assigns the stored field IDs.
+*
+* A root `description` becomes the table `comment`, and a field `description`
+* becomes its `doc`. `title` and `examples` are dropped.
+*
+* `Iceberg.identifier` sets the `identifier-field-ids`, and makes every other
+* top-level column nullable.
+*
+* @example
+* ```ts
+* const Row = Schema.Struct({
+*   id: Schema.String.pipe(Schema.annotateKey({ description: "Row identifier" })),
+* })
+*   .annotate({ description: "Connector rows" })
+*   .pipe(Iceberg.identifier("id"))
+*
+* const request = yield* Iceberg.makeCreateTableRequest(Row, {
+*   name: "rows",
+*   location: "s3://warehouse/rows"
+* })
+* ```
+*/
+const makeCreateTableRequest = (schema, options) => Effect.map(compileTable(schema), (table) => makeCreateRequest(table, options));
+//#endregion
+export { IcebergSchemaError as a, makeCreateTableRequest as i, compileTable as n, makeCreateRequest as r, checkHasRepresentation as t };
+
+//# sourceMappingURL=table-CxM09xf7.mjs.map

package/dist/table-CxM09xf7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-CxM09xf7.mjs","names":[],"sources":["../src/iceberg/error.ts","../src/iceberg/table.ts"],"sourcesContent":["import { Data } from \"effect\";\n\n/** A schema could not be turned into an Iceberg table. */\nexport class IcebergSchemaError extends Data.TaggedError(\"IcebergSchemaError\")<{\n  /** Schema path, such as `$.orders.element`. */\n  readonly path: string;\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n","import type {\n  CreateTableRequest,\n  IcebergType,\n  MapType,\n  StructField,\n  StructType,\n  TableSchema,\n} from \"iceberg-js\";\n\nimport { Effect, Schema, type SchemaRepresentation } from \"effect\";\n\nimport { IcebergSchemaError } from \"./error\";\n\n/** Options for creating a table. */\nexport type CreateTableOptions = {\n  readonly name: string;\n  /** Where the table's files go. The catalog may choose this when omitted. */\n  readonly location?: string | undefined;\n  /** Extra table properties. These win over the ones from the schema. */\n  readonly properties?: Readonly<Record<string, string>> | undefined;\n};\n\ntype Representation = SchemaRepresentation.Representation;\ntype Resolved = Exclude<Representation, SchemaRepresentation.Reference>;\ntype Annotations = Schema.Annotations.Annotations;\n\ntype CompiledType = {\n  readonly type: IcebergType;\n  readonly nullable: boolean;\n};\n\nexport type CompiledTable = {\n  readonly schema: TableSchema;\n  readonly description: string | undefined;\n};\n\nconst anonymousDeclaration =\n  \"Schemas without a name, such as Schema.Class, do not work here; use Schema.Struct\";\n\nclass CompilationFailure extends Error {\n  readonly path: string;\n\n  constructor(path: string, message: string) {\n    super(message);\n    this.path = path;\n  }\n}\n\nconst fail = (path: string, message: string): never => {\n  throw new CompilationFailure(path, message);\n};\n\nconst propertyPath = (path: string, name: string): string =>\n  /^[A-Za-z_$][\\w$]*$/.test(name) ? `${path}.${name}` : `${path}[${JSON.stringify(name)}]`;\n\n/** Reads annotations the way Effect does: if there are checks, the last one wins. */\nconst resolveAnnotations = (representation: Resolved): Annotations | undefined => {\n  const lastCheck = representation.checks.at(-1);\n  return lastCheck === undefined ? representation.annotations : lastCheck.annotations;\n};\n\nconst description = (annotations: Annotations | undefined): string | undefined => {\n  const value = annotations?.description;\n  return typeof value === \"string\" ? value : undefined;\n};\n\n/** @internal */\nexport const checkHasRepresentation = (\n  checks: ReadonlyArray<SchemaRepresentation.Check>,\n  id: string,\n): boolean =>\n  checks.some(\n    (check) =>\n      check.representation?.id === id ||\n      (check._tag === \"FilterGroup\" && checkHasRepresentation(check.checks, id)),\n  );\n\nconst isAnonymousDeclaration = (representation: Resolved): boolean =>\n  representation._tag === \"Declaration\" && representation.representation?.id === undefined;\n\nconst literalType = (\n  literal: SchemaRepresentation.Literal[\"literal\"],\n  path: string,\n): IcebergType => {\n  switch (typeof literal) {\n    case \"string\":\n      return \"string\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"number\":\n      return Number.isFinite(literal)\n        ? \"double\"\n        : fail(path, \"A number literal must be a real number, not Infinity or NaN\");\n    case \"bigint\":\n      return \"long\";\n    default:\n      return fail(path, `A ${typeof literal} literal does not work here`);\n  }\n};\n\nconst identifierId = (fields: ReadonlyArray<StructField>, name: string): number => {\n  const path = propertyPath(\"$\", name);\n  const field = fields.find((candidate) => candidate.name === name);\n\n  if (!field) return fail(path, \"Iceberg.identifier names a field that does not exist\");\n  if (!field.required) return fail(path, \"An identifier field cannot be optional or null\");\n  if (typeof field.type !== \"string\" || field.type === \"float\" || field.type === \"double\") {\n    return fail(path, \"An identifier field must be a primitive type other than float or double\");\n  }\n  return field.id;\n};\n\nconst assertNever = (_representation: never, path: string): never =>\n  fail(path, \"This kind of schema does not work here\");\n\nclass Compiler {\n  readonly #activeObjects = new Set<SchemaRepresentation.Objects>();\n  readonly #activeReferences = new Set<string>();\n  readonly #activeSuspends = new Set<SchemaRepresentation.Suspend>();\n  // The REST request needs IDs. Only the catalog's returned IDs are authoritative.\n  #nextId = 0;\n\n  constructor(private readonly references: SchemaRepresentation.References) {}\n\n  compile(root: Representation): CompiledTable {\n    return this.#withReference(root, \"$\", (representation) => {\n      if (isAnonymousDeclaration(representation)) return fail(\"$\", anonymousDeclaration);\n      if (representation._tag !== \"Objects\") {\n        return fail(\"$\", \"The top level of a table must be a Schema.Struct\");\n      }\n\n      const annotations = resolveAnnotations(representation);\n      const fields = this.#compileFields(representation, \"$\");\n      const identifierIds = (annotations?.icebergIdentifierFields ?? []).map((name) =>\n        identifierId(fields, name),\n      );\n\n      return {\n        schema:\n          identifierIds.length === 0\n            ? { type: \"struct\", fields }\n            : {\n                type: \"struct\",\n                // Deletes only send the key and version, so other columns must be nullable.\n                fields: fields.map((field) => ({\n                  ...field,\n                  required: identifierIds.includes(field.id),\n                })),\n                \"identifier-field-ids\": identifierIds,\n              },\n        description: description(annotations),\n      };\n    });\n  }\n\n  #withReference<A>(\n    representation: Representation,\n    path: string,\n    compile: (resolved: Resolved) => A,\n  ): A {\n    if (representation._tag !== \"Reference\") return compile(representation);\n\n    const reference = representation.$ref;\n    const resolved = this.references[reference];\n    if (resolved === undefined) return fail(path, `Cannot find the schema named ${reference}`);\n    if (this.#activeReferences.has(reference)) {\n      return fail(path, \"Iceberg cannot store a schema that contains itself\");\n    }\n\n    this.#activeReferences.add(reference);\n    try {\n      return this.#withReference(resolved, path, compile);\n    } finally {\n      this.#activeReferences.delete(reference);\n    }\n  }\n\n  #checkRecursion(representation: Representation, path: string): void {\n    if (representation._tag === \"Reference\" && this.#activeReferences.has(representation.$ref)) {\n      fail(path, \"Iceberg cannot store a schema that contains itself\");\n    }\n  }\n\n  #compileFields(representation: SchemaRepresentation.Objects, path: string): Array<StructField> {\n    if (representation.indexSignatures.length > 0) {\n      return fail(\n        path,\n        \"Schema.Record does not work here; name the keys with Schema.Struct, or store it as a JSON string\",\n      );\n    }\n\n    return representation.propertySignatures.map((property) => {\n      if (typeof property.name !== \"string\") {\n        return fail(\n          propertyPath(path, String(property.name)),\n          \"Iceberg field names must be strings\",\n        );\n      }\n\n      const fieldPath = propertyPath(path, property.name);\n      this.#checkRecursion(property.type, fieldPath);\n      const id = ++this.#nextId;\n      const compiled = this.#compileType(property.type, fieldPath);\n      const fieldDescription = description(property.annotations);\n\n      return {\n        id,\n        name: property.name,\n        type: compiled.type,\n        required: !property.isOptional && !compiled.nullable,\n        ...(fieldDescription === undefined ? {} : { doc: fieldDescription }),\n      };\n    });\n  }\n\n  #compileType(representation: Representation, path: string): CompiledType {\n    if (representation._tag === \"Reference\") {\n      return this.#withReference(representation, path, (resolved) =>\n        this.#compileType(resolved, path),\n      );\n    }\n\n    switch (representation._tag) {\n      case \"String\":\n        return { type: \"string\", nullable: false };\n      case \"Boolean\":\n        return { type: \"boolean\", nullable: false };\n      case \"BigInt\":\n        return { type: \"long\", nullable: false };\n      case \"Number\":\n        // Schema.Int can exceed Iceberg int. A double holds every safe integer\n        // exactly; a long would need bigint rows.\n        return checkHasRepresentation(representation.checks, \"effect/schema/isFinite\") ||\n          checkHasRepresentation(representation.checks, \"effect/schema/isInt\")\n          ? { type: \"double\", nullable: false }\n          : fail(path, \"Plain Schema.Number does not work here; use Schema.Finite or Schema.Int\");\n      case \"Literal\":\n        return { type: literalType(representation.literal, path), nullable: false };\n      case \"Objects\": {\n        if (this.#activeObjects.has(representation)) {\n          return fail(path, \"Iceberg cannot store a schema that contains itself\");\n        }\n\n        this.#activeObjects.add(representation);\n        try {\n          return {\n            type: {\n              type: \"struct\",\n              fields: this.#compileFields(representation, path),\n            } satisfies StructType,\n            nullable: false,\n          };\n        } finally {\n          this.#activeObjects.delete(representation);\n        }\n      }\n      case \"Arrays\":\n        return this.#compileArray(representation, path);\n      case \"Declaration\":\n        return this.#compileDeclaration(representation, path);\n      case \"Union\":\n        return this.#compileUnion(representation, path);\n      case \"Suspend\": {\n        if (this.#activeSuspends.has(representation)) {\n          return fail(path, \"Iceberg cannot store a schema that contains itself\");\n        }\n\n        this.#activeSuspends.add(representation);\n        try {\n          return this.#compileType(representation.thunk, path);\n        } finally {\n          this.#activeSuspends.delete(representation);\n        }\n      }\n      case \"Null\":\n      case \"Undefined\":\n        return fail(path, \"A field cannot contain only null or undefined\");\n      case \"Any\":\n      case \"Unknown\":\n      case \"ObjectKeyword\":\n      case \"Symbol\":\n      case \"UniqueSymbol\":\n      case \"Void\":\n      case \"Never\":\n      case \"Enum\":\n      case \"TemplateLiteral\":\n        return fail(path, `A ${representation._tag} schema does not work here`);\n      default:\n        return assertNever(representation, path);\n    }\n  }\n\n  #compileArray(representation: SchemaRepresentation.Arrays, path: string): CompiledType {\n    if (representation.elements.length > 0 || representation.rest.length !== 1) {\n      return fail(\n        path,\n        \"A tuple does not work here; use a Schema.Array where every item has the same type\",\n      );\n    }\n\n    const elementPath = `${path}.element`;\n    const elementRepresentation = representation.rest[0]!;\n    const elementId = ++this.#nextId;\n    const compiled = this.#compileType(elementRepresentation, elementPath);\n\n    return {\n      type: {\n        type: \"list\",\n        \"element-id\": elementId,\n        element: compiled.type,\n        \"element-required\": !compiled.nullable,\n      },\n      nullable: false,\n    };\n  }\n\n  #compileDeclaration(\n    representation: SchemaRepresentation.Declaration,\n    path: string,\n  ): CompiledType {\n    const id = representation.representation?.id;\n\n    switch (id) {\n      case \"effect/schema/Date\":\n        return { type: \"timestamptz\", nullable: false };\n      case \"effect/schema/Uint8Array\":\n        return { type: \"binary\", nullable: false };\n      case \"effect/schema/ReadonlyMap\":\n        return this.#compileMap(representation, path);\n      case undefined:\n        return fail(path, anonymousDeclaration);\n      default:\n        return fail(path, `The ${id} schema does not work here`);\n    }\n  }\n\n  #compileMap(representation: SchemaRepresentation.Declaration, path: string): CompiledType {\n    if (representation.typeParameters.length !== 2) {\n      return fail(path, \"ReadonlyMap needs one key schema and one value schema\");\n    }\n\n    const keyPath = `${path}.key`;\n    const valuePath = `${path}.value`;\n    const keyRepresentation = representation.typeParameters[0]!;\n    const valueRepresentation = representation.typeParameters[1]!;\n    const keyId = ++this.#nextId;\n    const compiledKey = this.#compileType(keyRepresentation, keyPath);\n\n    if (compiledKey.nullable) return fail(keyPath, \"Map keys cannot be null\");\n\n    const valueId = ++this.#nextId;\n    const compiledValue = this.#compileType(valueRepresentation, valuePath);\n\n    return {\n      type: {\n        type: \"map\",\n        \"key-id\": keyId,\n        key: compiledKey.type,\n        \"value-id\": valueId,\n        value: compiledValue.type,\n        \"value-required\": !compiledValue.nullable,\n      } satisfies MapType,\n      nullable: false,\n    };\n  }\n\n  #compileUnion(representation: SchemaRepresentation.Union, path: string): CompiledType {\n    let nullable = false;\n    const concrete: Array<Representation> = [];\n\n    for (const member of representation.types) {\n      if (member._tag === \"Null\" || member._tag === \"Undefined\") {\n        nullable = true;\n      } else {\n        concrete.push(member);\n      }\n    }\n\n    if (concrete.length === 0) return fail(path, \"A field cannot contain only null or undefined\");\n\n    if (concrete.length === 1) {\n      const compiled = this.#compileType(concrete[0]!, path);\n      return { type: compiled.type, nullable: nullable || compiled.nullable };\n    }\n\n    if (!concrete.every((member) => member._tag === \"Literal\")) {\n      return fail(path, \"A union only works when every member is a literal\");\n    }\n\n    const first = literalType(concrete[0]!.literal, path);\n    for (const member of concrete.slice(1)) {\n      if (literalType(member.literal, path) !== first) {\n        return fail(path, \"Every literal in a union must be the same type\");\n      }\n    }\n\n    return { type: first, nullable };\n  }\n}\n\nexport const compileTable = (\n  schema: Schema.Top,\n): Effect.Effect<CompiledTable, IcebergSchemaError> =>\n  Effect.try({\n    try: () => {\n      const document = Schema.toRepresentation(Schema.toType(schema));\n      return new Compiler(document.references).compile(document.representation);\n    },\n    catch: (cause) =>\n      cause instanceof CompilationFailure\n        ? new IcebergSchemaError({ path: cause.path, message: cause.message, cause })\n        : new IcebergSchemaError({\n            path: \"$\",\n            message: cause instanceof Error ? cause.message : String(cause),\n            cause,\n          }),\n  });\n\nexport const makeCreateRequest = (\n  table: CompiledTable,\n  options: CreateTableOptions,\n): CreateTableRequest => ({\n  name: options.name,\n  schema: table.schema,\n  ...(options.location === undefined ? {} : { location: options.location }),\n  properties: {\n    ...(table.description === undefined ? {} : { comment: table.description }),\n    ...options.properties,\n    \"format-version\": \"3\",\n  },\n});\n\n/**\n * Builds a REST create-table request from an Effect schema.\n * The catalog assigns the stored field IDs.\n *\n * A root `description` becomes the table `comment`, and a field `description`\n * becomes its `doc`. `title` and `examples` are dropped.\n *\n * `Iceberg.identifier` sets the `identifier-field-ids`, and makes every other\n * top-level column nullable.\n *\n * @example\n * ```ts\n * const Row = Schema.Struct({\n *   id: Schema.String.pipe(Schema.annotateKey({ description: \"Row identifier\" })),\n * })\n *   .annotate({ description: \"Connector rows\" })\n *   .pipe(Iceberg.identifier(\"id\"))\n *\n * const request = yield* Iceberg.makeCreateTableRequest(Row, {\n *   name: \"rows\",\n *   location: \"s3://warehouse/rows\"\n * })\n * ```\n */\nexport const makeCreateTableRequest = (\n  schema: Schema.Top,\n  options: CreateTableOptions,\n): Effect.Effect<CreateTableRequest, IcebergSchemaError> =>\n  Effect.map(compileTable(schema), (table) => makeCreateRequest(table, options));\n"],"mappings":"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"}

package/dist/types-NtSv6gwl.d.mts

@@ -0,0 +1,220 @@
+import { t as ConnectorError } from "./index-DkVNO6ks.mjs";
+import { n as RequiredField, t as Identified } from "./annotations-vzSzXtr-.mjs";
+import { Duration, Effect, Schema } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+//#region src/core/types.d.ts
+declare namespace Cursor {
+  type Value = string | number | Date;
+  type Kind = "string" | "number" | "isoDateTime";
+  type Definition<T extends Value = Value> = {
+    readonly kind: Kind;
+    readonly decode: (value: unknown) => Effect.Effect<T, ConnectorError>;
+  };
+}
+/** Rows and an optional cursor from one resource. */
+type ResourceBatch<Row extends object = object> = {
+  readonly cursor?: Cursor.Value;
+  readonly rows: ReadonlyArray<Row>;
+};
+type ResourceState = {
+  readonly backfill?: {
+    readonly cutoff: Cursor.Value;
+    readonly pageCursor?: Cursor.Value;
+    readonly completed: boolean;
+    readonly lastSuccessAt?: string;
+  };
+  readonly changes?: {
+    readonly cursor: Cursor.Value;
+    readonly lastSuccessAt?: string;
+  };
+  readonly lastError?: {
+    readonly source: "backfill" | "changes";
+    readonly operation: "fetch" | "ingest" | "checkpoint";
+    readonly code: "fetch_failed" | "ingest_failed" | "checkpoint_failed";
+    readonly message: string;
+    readonly at: string;
+  };
+};
+type SyncState = "pending" | "backfilling" | "live" | "error";
+/** A row schema with its key, set by `Iceberg.identifier`. */
+type ResourceSchema = Schema.Decoder<object> & Identified<string>;
+/**
+ * Takes a resource schema and returns its decoded row object type.
+ *
+ * @example
+ * ```ts
+ * const ProductSchema = Schema.Struct({ id: Schema.String, updatedAt: Schema.String }).pipe(
+ *   Iceberg.identifier("id"),
+ * );
+ * type Product = ResourceRow<typeof ProductSchema>;
+ * // Result:
+ * // type Product = { readonly id: string; readonly updatedAt: string }
+ * ```
+ */
+type ResourceRow<S extends ResourceSchema> = Schema.Schema.Type<S>;
+/**
+ * Takes a resource schema and returns the string keys available on its row type.
+ *
+ * @example
+ * ```ts
+ * const ProductSchema = Schema.Struct({ id: Schema.String, updatedAt: Schema.String }).pipe(
+ *   Iceberg.identifier("id"),
+ * );
+ * type ProductField = ResourceField<typeof ProductSchema>;
+ * // Result:
+ * // type ProductField = "id" | "updatedAt"
+ *
+ * const version: ResourceField<typeof ProductSchema> = "updatedAt";
+ * ```
+ */
+type KnownResourceField<S extends ResourceSchema> = keyof ResourceRow<S> & string;
+type ResourceField<S extends ResourceSchema> = [KnownResourceField<S>] extends [never] ? string : KnownResourceField<S>;
+/** A row field that cannot be null or undefined. */
+type ResourceRequiredField<S extends ResourceSchema> = RequiredField<S>;
+/** The fields that identify a row, from `Iceberg.identifier`. */
+type ResourceKey<S extends ResourceSchema> = S extends Identified<infer Key> ? Key : never;
+/** Deletes a row: its key, version, and `_deleted: true`. */
+type ResourceDelete<S extends ResourceSchema, Version extends ResourceField<S>> = Pick<ResourceRow<S>, Extract<ResourceKey<S> | Version, keyof ResourceRow<S>>> & {
+  readonly _deleted: true;
+};
+/** A full row, or a delete. The engine replaces the whole row. */
+type ResourceUpdate<S extends ResourceSchema, Version extends ResourceField<S>> = (ResourceRow<S> & {
+  readonly _deleted?: boolean;
+}) | ResourceDelete<S, Version>;
+type FetchPageResult<Row extends object> = {
+  readonly rows: ReadonlyArray<Row>;
+  readonly nextPageCursor?: Cursor.Value;
+  readonly hasMore: boolean;
+};
+type PageFetch<Row extends object, R = never> = {
+  readonly pageCursor: Cursor.Definition;
+  readonly cutoff: Cursor.Definition;
+  readonly fetch: (input: {
+    readonly pageCursor?: Cursor.Value;
+    readonly cutoff: Cursor.Value;
+  }) => Effect.Effect<FetchPageResult<Row>, ConnectorError, R>;
+};
+type FetchChangesResult<Row extends object> = {
+  readonly rows: ReadonlyArray<Row>;
+  readonly cursor: Cursor.Value;
+  /** When true, the engine runs the changes again without waiting for the interval. */
+  readonly hasMore?: boolean;
+};
+type ChangesFetch<Row extends object, R = never> = {
+  readonly cursor: Cursor.Definition;
+  readonly interval?: Duration.Input;
+  readonly fetch: (input: {
+    readonly cursor: Cursor.Value;
+  }) => Effect.Effect<FetchChangesResult<Row>, ConnectorError, R>;
+};
+type WebhookHandler<Row extends object, Payload> = {
+  /** Types the payload. The route decodes it before `to`. */
+  readonly schema: Schema.Decoder<Payload>;
+  handler(input: {
+    readonly payload: Payload;
+  }): Effect.Effect<ReadonlyArray<Row>, ConnectorError>;
+};
+type ResourceDefinition<S extends ResourceSchema = ResourceSchema, Payload = unknown, R = never, Name extends string = string, Version extends ResourceRequiredField<S> = ResourceRequiredField<S>> = {
+  readonly name: Name;
+  /** Types the rows, and names the key. The Iceberg table decides how they are encoded. */
+  readonly rowSchema: S;
+  /** Orders updates for the entity. */
+  readonly version: Version;
+  /** Read-only validation used before provisioning this resource. */
+  readonly check: Effect.Effect<void, ConnectorError>;
+  readonly backfill?: PageFetch<ResourceRow<NoInfer<S>>, R>;
+  readonly changes?: ChangesFetch<ResourceUpdate<NoInfer<S>, NoInfer<Version>>, R>;
+  readonly webhook?: WebhookHandler<ResourceUpdate<NoInfer<S>, NoInfer<Version>>, Payload>;
+};
+/** The parts of a resource its table needs. */
+type TableResource = Pick<ResourceDefinition, "name" | "rowSchema" | "version">;
+/** Resources that write to tables, such as a connector or a demo. */
+type TableSource = {
+  readonly resources: ReadonlyArray<TableResource>;
+};
+/**
+ * Takes a connector resource tuple and returns a `{ [resourceName]: rowType }`
+ * map.
+ *
+ * @example
+ * ```ts
+ * type Rows = ResourceRows<[typeof Products, typeof Orders]>;
+ * // Result:
+ * // type Rows = {
+ * //   readonly products: Product;
+ * //   readonly orders: Order;
+ * // }
+ *
+ * type ProductRow = Rows["products"];
+ * // Result:
+ * // type ProductRow = Product
+ * ```
+ */
+type ResourceRows<Resources extends ReadonlyArray<ResourceDefinition>> = { readonly [Resource in Resources[number] as Resource["name"]]: Resource extends ResourceDefinition<infer S, unknown, unknown, string, infer _Version> ? ResourceRow<S> : never; };
+/** Resource names preserved from a connector's resource tuple. */
+type ResourceName<Resources extends ReadonlyArray<ResourceDefinition>> = keyof ResourceRows<Resources> & string;
+/**
+ * Takes a resource definition and returns the payload type accepted by
+ * `to(resource, payload)`.
+ *
+ * @example
+ * ```ts
+ * type ProductPayload = ResourcePayload<typeof Products>;
+ * // Result, if Products was defined with a ProductEvent webhook schema:
+ * // type ProductPayload = ProductEvent
+ * ```
+ */
+type ResourcePayload<R> = R extends ResourceDefinition<ResourceSchema, infer Payload, unknown, string, string> ? Payload : never;
+type WebhookAckMode = "after-enqueue" | "after-ingest";
+type WebhookRouteContext<Resources extends ReadonlyArray<ResourceDefinition> = ReadonlyArray<ResourceDefinition>, Payload = unknown> = {
+  readonly request: HttpServerRequest.HttpServerRequest;
+  readonly rawBody: Uint8Array;
+  readonly payload: Payload;
+  /** Runs a resource's webhook handler on a decoded payload and collects its rows. */
+  readonly to: <Resource extends Resources[number]>(resource: Resource, payload: ResourcePayload<Resource>) => Effect.Effect<void, ConnectorError>;
+};
+type WebhookRoute<Resources extends ReadonlyArray<ResourceDefinition> = ReadonlyArray<ResourceDefinition>, Payload = unknown> = {
+  readonly path: HttpRouter.PathInput;
+  readonly ackMode: WebhookAckMode;
+  readonly schema: Schema.Decoder<Payload>;
+  handler(context: WebhookRouteContext<Resources, Payload>): Effect.Effect<HttpServerResponse.HttpServerResponse, ConnectorError>;
+};
+type WebhookRouteInput<Resources extends ReadonlyArray<ResourceDefinition>, Payload> = WebhookRoute<Resources, Payload>;
+/**
+ * Takes a resource definition and returns the rows its changes and webhooks may
+ * return: full rows or deletes.
+ */
+type ResourceUpdateOf<R> = R extends ResourceDefinition<infer S, unknown, unknown, string, infer Version> ? ResourceUpdate<S, Version> : never;
+/** Rows from one feed run, by resource name. A missing resource has no rows. */
+type FeedRows<Resources extends ReadonlyArray<ResourceDefinition>> = { readonly [Resource in Resources[number] as Resource["name"]]?: ReadonlyArray<ResourceUpdateOf<Resource>>; };
+type FetchFeedResult<Resources extends ReadonlyArray<ResourceDefinition>> = {
+  readonly rows: FeedRows<Resources>;
+  readonly cursor: Cursor.Value;
+  /** When true, the engine runs the feed again without waiting for the interval. */
+  readonly hasMore?: boolean;
+};
+/**
+ * One changes source for several resources, with one cursor. Use it when one
+ * provider log, such as an events API, covers them all.
+ */
+type ChangesFeed<Resources extends ReadonlyArray<ResourceDefinition> = ReadonlyArray<ResourceDefinition>, R = never> = {
+  readonly resources: Resources;
+  readonly cursor: Cursor.Definition;
+  readonly interval?: Duration.Input;
+  readonly fetch: (input: {
+    readonly cursor: Cursor.Value;
+    /** The resources that run. Skip the work for the others. */
+    readonly selected: ReadonlySet<string>;
+  }) => Effect.Effect<FetchFeedResult<Resources>, ConnectorError, R>;
+};
+type ConnectorDefinition<Resources extends ReadonlyArray<ResourceDefinition> = ReadonlyArray<ResourceDefinition>, FeedResources extends ReadonlyArray<ResourceDefinition> = ReadonlyArray<ResourceDefinition>> = {
+  readonly name: string;
+  readonly title?: string;
+  readonly resources: Resources;
+  /** Shared changes for resources that do not define their own `changes`. */
+  readonly changes?: ChangesFeed<FeedResources>;
+  readonly webhooks?: ReadonlyArray<WebhookRoute>;
+};
+//#endregion
+export { WebhookRouteContext as A, ResourceUpdateOf as C, WebhookAckMode as D, TableSource as E, WebhookHandler as O, ResourceUpdate as S, TableResource as T, ResourceRequiredField as _, FeedRows as a, ResourceSchema as b, FetchPageResult as c, ResourceDefinition as d, ResourceDelete as f, ResourcePayload as g, ResourceName as h, Cursor as i, WebhookRouteInput as j, WebhookRoute as k, PageFetch as l, ResourceKey as m, ChangesFetch as n, FetchChangesResult as o, ResourceField as p, ConnectorDefinition as r, FetchFeedResult as s, ChangesFeed as t, ResourceBatch as u, ResourceRow as v, SyncState as w, ResourceState as x, ResourceRows as y };
+//# sourceMappingURL=types-NtSv6gwl.d.mts.map

package/dist/webhook/index.d.mts

@@ -0,0 +1,3 @@
+import { A as WebhookRouteContext, D as WebhookAckMode, j as WebhookRouteInput, k as WebhookRoute } from "../types-NtSv6gwl.mjs";
+import { n as route, r as router } from "../index-dHS59EZl.mjs";
+export { type WebhookAckMode, type WebhookRoute, type WebhookRouteContext, type WebhookRouteInput, route, router };

package/dist/webhook/index.mjs

@@ -0,0 +1,12 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as router } from "../server-D1TTN0_D.mjs";
+//#region src/webhook/index.ts
+var webhook_exports = /* @__PURE__ */ __exportAll({
+	route: () => route,
+	router: () => router
+});
+const route = (definition) => definition;
+//#endregion
+export { route, router, webhook_exports as t };
+
+//# sourceMappingURL=index.mjs.map

package/dist/webhook/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/webhook/index.ts"],"sourcesContent":["import type { ResourceDefinition, WebhookRoute, WebhookRouteInput } from \"../core/types\";\n\nexport { router } from \"./server\";\nexport type { WebhookAckMode, WebhookRoute, WebhookRouteContext, WebhookRouteInput } from \"./types\";\n\nexport const route = <const Resources extends ReadonlyArray<ResourceDefinition>, Payload>(\n  definition: WebhookRouteInput<Resources, Payload>,\n): WebhookRoute<Resources, Payload> => definition;\n"],"mappings":";;;;;;;AAKA,MAAa,SACX,eACqC"}