@sixb/core 0.1.0 → 0.1.2

package/dist/{chunk-r65yscvk.js → chunk-a31h57d5.js}

@@ -4,10 +4,11 @@ import {
 } from "./chunk-04b07a9q.js";
 import {
   isFileRef
-} from "./chunk-4pycxcj3.js";
+} from "./chunk-zqysyfjt.js";
 import {
-  isJsonValue
-} from "./chunk-1vffvydj.js";
+  isJsonValue,
+  isPlainRecord
+} from "./chunk-t8t39h7v.js";
 
 // src/datasets/errors.ts
 class DatasetValidationError extends Error {
@@ -29,13 +30,6 @@ var datasetColumnTypes = new Set([
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isPlainObject(value) {
-  if (!isRecord(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
 function isValidDateValue(value) {
   return value instanceof Date && !Number.isNaN(value.getTime());
 }
@@ -97,6 +91,40 @@ function assertDatasetSchema(schema, createError) {
     seenColumnNames.add(column.name);
   }
 }
+function assertDatasetPrimaryKey(primaryKey, schema, createError) {
+  let keyColumns;
+  if (typeof primaryKey === "string") {
+    keyColumns = [primaryKey];
+  } else if (Array.isArray(primaryKey)) {
+    if (primaryKey.length < 2) {
+      throw createError("Dataset primaryKey arrays must contain at least two column names. Use a string for a single-column key.");
+    }
+    keyColumns = primaryKey;
+  } else {
+    throw createError("Dataset primaryKey must be a column name or an array of at least two column names.");
+  }
+  const columnsByName = new Map(schema.columns.map((column) => [column.name, column]));
+  const seenColumnNames = new Set;
+  for (const columnName of keyColumns) {
+    if (typeof columnName !== "string" || columnName.trim().length === 0) {
+      throw createError("Dataset primaryKey columns must be non-empty strings.");
+    }
+    if (seenColumnNames.has(columnName)) {
+      throw createError(`Dataset primaryKey contains duplicate column '${columnName}'.`);
+    }
+    seenColumnNames.add(columnName);
+    const column = columnsByName.get(columnName);
+    if (column === undefined) {
+      throw createError(`Dataset primaryKey column '${columnName}' is not declared in the schema.`);
+    }
+    if (column.type !== "string") {
+      throw createError(`Dataset primaryKey column '${columnName}' must have type 'string'.`);
+    }
+    if (column.nullable === true) {
+      throw createError(`Dataset primaryKey column '${columnName}' must not be nullable.`);
+    }
+  }
+}
 function assertDatasetDefinition(definition, createError = (message) => new DatasetValidationError(message)) {
   if (!isRecord(definition)) {
     throw createError("Dataset definition must be an object.");
@@ -106,6 +134,9 @@ function assertDatasetDefinition(definition, createError = (message) => new Data
   }
   assertNonEmptyString(definition.id, "Dataset id", createError);
   assertDatasetSchema(definition.schema, createError);
+  if (definition.primaryKey !== undefined) {
+    assertDatasetPrimaryKey(definition.primaryKey, definition.schema, createError);
+  }
   if (definition.partitionBy !== undefined) {
     if (!Array.isArray(definition.partitionBy)) {
       throw createError("Dataset partitionBy must be an array of column names.");
@@ -131,7 +162,7 @@ function isDatasetDefinition(value) {
   }
 }
 function getDatasetRowValidationError(row, dataset, options) {
-  if (!isPlainObject(row)) {
+  if (!isPlainRecord(row)) {
     return `Dataset '${dataset.id}' rows must be plain objects.`;
   }
   const columnsByName = new Map(dataset.schema.columns.map((column) => [column.name, column]));
@@ -182,6 +213,93 @@ function getColumnValidationError(row, column, dataset) {
   return null;
 }
 
-export { DatasetValidationError, assertDatasetColumnDefinition, assertDatasetDefinition, isDatasetDefinition, getDatasetRowValidationError };
+// src/datasets/builders.ts
+function col(name, type, options) {
+  const column = {
+    name,
+    type,
+    ...options?.nullable !== undefined ? { nullable: options.nullable } : {}
+  };
+  assertDatasetColumnDefinition(column, (message) => new DatasetValidationError(message));
+  return column;
+}
+function assertDatasetId(id) {
+  if (!id.trim()) {
+    throw new DatasetValidationError("Dataset id must not be empty.");
+  }
+}
+function createDatasetDefinition(id, options) {
+  const definition = {
+    kind: "dataset",
+    id,
+    schema: {
+      columns: [...options.schema]
+    },
+    ...options.primaryKey !== undefined ? {
+      primaryKey: Array.isArray(options.primaryKey) ? [...options.primaryKey] : options.primaryKey
+    } : {},
+    ...options.partitionBy !== undefined ? { partitionBy: [...options.partitionBy] } : {},
+    ...options.description !== undefined ? { description: options.description } : {}
+  };
+  assertDatasetDefinition(definition, (message) => new DatasetValidationError(message));
+  return definition;
+}
+function assertStringArray(value, field) {
+  if (!Array.isArray(value)) {
+    throw new DatasetValidationError(`${field} must be an array of column names.`);
+  }
+  for (const item of value) {
+    if (typeof item !== "string" || !item.trim()) {
+      throw new DatasetValidationError(`${field} must contain only non-empty column names.`);
+    }
+  }
+}
+function deriveDatasetDefinition(id, parent, options = {}) {
+  assertDatasetDefinition(parent, (message) => new DatasetValidationError(message));
+  if (options.pick !== undefined) {
+    assertStringArray(options.pick, "Dataset derive pick");
+  }
+  if (options.add !== undefined && !Array.isArray(options.add)) {
+    throw new DatasetValidationError("Dataset derive add must be an array of columns.");
+  }
+  const parentColumnsByName = new Map(parent.schema.columns.map((column) => [column.name, column]));
+  const pickedColumns = options.pick === undefined ? parent.schema.columns : options.pick.map((columnName) => {
+    const column = parentColumnsByName.get(columnName);
+    if (column === undefined) {
+      throw new DatasetValidationError(`Dataset derive pick column '${columnName}' is not declared on parent dataset '${parent.id}'.`);
+    }
+    return column;
+  });
+  return createDatasetDefinition(id, {
+    schema: [...pickedColumns, ...options.add ?? []],
+    ...options.primaryKey !== undefined ? { primaryKey: options.primaryKey } : {},
+    ...options.partitionBy !== undefined ? { partitionBy: options.partitionBy } : {},
+    ...options.description !== undefined ? { description: options.description } : {}
+  });
+}
+function createDatasetDeriveBuilder(id) {
+  assertDatasetId(id);
+  function derive(parent, options) {
+    return deriveDatasetDefinition(id, parent, options);
+  }
+  return { derive };
+}
+function defineDataset(id, options) {
+  if (options === undefined) {
+    return createDatasetDeriveBuilder(id);
+  }
+  return createDatasetDefinition(id, options);
+}
+
+// src/datasets/changes.ts
+var change = {
+  upsert(row) {
+    return { kind: "upsert", row };
+  },
+  delete(key) {
+    return { kind: "delete", key };
+  }
+};
+export { DatasetValidationError, assertDatasetDefinition, isDatasetDefinition, getDatasetRowValidationError, col, defineDataset, change };
 
-//# debugId=A9CE83DDF8F42C6B64756E2164756E21
+//# debugId=5BD3A97C32D4B31E64756E2164756E21

package/dist/chunk-a31h57d5.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/datasets/errors.ts", "../src/datasets/validation.ts", "../src/datasets/builders.ts", "../src/datasets/changes.ts"],
+  "sourcesContent": [
+    "export class DatasetValidationError extends Error {\n  readonly name = \"DatasetValidationError\"\n}\n",
+    "import { isFileRef } from \"../blob-storage\"\nimport { isJsonValue, isPlainRecord } from \"../json\"\nimport { isDecimalString } from \"../ontology/decimal\"\nimport { DatasetValidationError } from \"./errors\"\nimport type {\n  DatasetColumnDefinition,\n  DatasetColumnType,\n  DatasetDefinition,\n  DatasetSchema,\n} from \"./types\"\n\nconst datasetColumnTypes = new Set<DatasetColumnType>([\n  \"string\",\n  \"boolean\",\n  \"int64\",\n  \"float64\",\n  \"decimal\",\n  \"date\",\n  \"timestamp\",\n  \"json\",\n  \"fileRef\",\n])\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value)\n}\n\nfunction isValidDateValue(value: unknown): boolean {\n  return value instanceof Date && !Number.isNaN(value.getTime())\n}\n\nfunction isDateString(value: unknown): value is string {\n  return (\n    typeof value === \"string\" &&\n    /^\\d{4}-\\d{2}-\\d{2}$/.test(value) &&\n    !Number.isNaN(Date.parse(value))\n  )\n}\n\nfunction isTimestampString(value: unknown): value is string {\n  return typeof value === \"string\" && !Number.isNaN(Date.parse(value))\n}\n\nfunction matchesColumnType(value: unknown, type: DatasetColumnType): boolean {\n  switch (type) {\n    case \"string\":\n      return typeof value === \"string\"\n    case \"boolean\":\n      return typeof value === \"boolean\"\n    case \"int64\":\n      return (\n        (typeof value === \"number\" && Number.isInteger(value)) ||\n        (typeof value === \"string\" && /^-?\\d+$/.test(value))\n      )\n    case \"float64\":\n      return typeof value === \"number\" && Number.isFinite(value)\n    case \"decimal\":\n      return isDecimalString(value)\n    case \"date\":\n      return isValidDateValue(value) || isDateString(value)\n    case \"timestamp\":\n      return isValidDateValue(value) || isTimestampString(value)\n    case \"json\":\n      return isJsonValue(value)\n    case \"fileRef\":\n      return isFileRef(value)\n  }\n}\n\nfunction assertNonEmptyString(\n  value: unknown,\n  field: string,\n  createError: (message: string) => Error\n): asserts value is string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw createError(`${field} must not be empty.`)\n  }\n}\n\nexport function assertDatasetColumnDefinition(\n  column: unknown,\n  createError: (message: string) => Error,\n  fieldPrefix = \"Dataset column\"\n): asserts column is DatasetColumnDefinition {\n  if (!isRecord(column)) {\n    throw createError(`${fieldPrefix} must be an object.`)\n  }\n\n  assertNonEmptyString(column.name, `${fieldPrefix} name`, createError)\n\n  if (!datasetColumnTypes.has(column.type as DatasetColumnType)) {\n    throw createError(\n      `${fieldPrefix} '${column.name}' has an invalid type '${String(column.type)}'.`\n    )\n  }\n\n  if (column.nullable !== undefined && typeof column.nullable !== \"boolean\") {\n    throw createError(`${fieldPrefix} '${column.name}' nullable must be a boolean.`)\n  }\n}\n\nfunction assertDatasetSchema(\n  schema: unknown,\n  createError: (message: string) => Error\n): asserts schema is DatasetSchema {\n  if (!isRecord(schema) || !Array.isArray(schema.columns)) {\n    throw createError(\"Dataset definitions must declare a schema.\")\n  }\n\n  const seenColumnNames = new Set<string>()\n  for (const column of schema.columns) {\n    assertDatasetColumnDefinition(column, createError)\n\n    if (seenColumnNames.has(column.name)) {\n      throw createError(`Dataset schema contains a duplicate column '${column.name}'.`)\n    }\n\n    seenColumnNames.add(column.name)\n  }\n}\n\nfunction assertDatasetPrimaryKey(\n  primaryKey: unknown,\n  schema: DatasetSchema,\n  createError: (message: string) => Error\n): void {\n  let keyColumns: readonly unknown[]\n  if (typeof primaryKey === \"string\") {\n    keyColumns = [primaryKey]\n  } else if (Array.isArray(primaryKey)) {\n    if (primaryKey.length < 2) {\n      throw createError(\n        \"Dataset primaryKey arrays must contain at least two column names. Use a string for a single-column key.\"\n      )\n    }\n    keyColumns = primaryKey\n  } else {\n    throw createError(\n      \"Dataset primaryKey must be a column name or an array of at least two column names.\"\n    )\n  }\n\n  const columnsByName = new Map(schema.columns.map((column) => [column.name, column] as const))\n  const seenColumnNames = new Set<string>()\n\n  for (const columnName of keyColumns) {\n    if (typeof columnName !== \"string\" || columnName.trim().length === 0) {\n      throw createError(\"Dataset primaryKey columns must be non-empty strings.\")\n    }\n\n    if (seenColumnNames.has(columnName)) {\n      throw createError(`Dataset primaryKey contains duplicate column '${columnName}'.`)\n    }\n    seenColumnNames.add(columnName)\n\n    const column = columnsByName.get(columnName)\n    if (column === undefined) {\n      throw createError(`Dataset primaryKey column '${columnName}' is not declared in the schema.`)\n    }\n    if (column.type !== \"string\") {\n      throw createError(`Dataset primaryKey column '${columnName}' must have type 'string'.`)\n    }\n    if (column.nullable === true) {\n      throw createError(`Dataset primaryKey column '${columnName}' must not be nullable.`)\n    }\n  }\n}\n\nexport function assertDatasetDefinition(\n  definition: unknown,\n  createError: (message: string) => Error = (message) => new DatasetValidationError(message)\n): asserts definition is DatasetDefinition {\n  if (!isRecord(definition)) {\n    throw createError(\"Dataset definition must be an object.\")\n  }\n\n  if (definition.kind !== \"dataset\") {\n    throw createError(\"Dataset definition kind must be 'dataset'.\")\n  }\n\n  assertNonEmptyString(definition.id, \"Dataset id\", createError)\n  assertDatasetSchema(definition.schema, createError)\n\n  if (definition.primaryKey !== undefined) {\n    assertDatasetPrimaryKey(definition.primaryKey, definition.schema, createError)\n  }\n\n  if (definition.partitionBy !== undefined) {\n    if (!Array.isArray(definition.partitionBy)) {\n      throw createError(\"Dataset partitionBy must be an array of column names.\")\n    }\n\n    const columnNames = new Set(definition.schema.columns.map((column) => column.name))\n    for (const columnName of definition.partitionBy) {\n      assertNonEmptyString(columnName, \"Dataset partition column\", createError)\n      if (!columnNames.has(columnName)) {\n        throw createError(`Dataset partition column '${columnName}' is not declared in the schema.`)\n      }\n    }\n  }\n\n  if (definition.description !== undefined && typeof definition.description !== \"string\") {\n    throw createError(\"Dataset description must be a string.\")\n  }\n}\n\nexport function isDatasetDefinition(value: unknown): value is DatasetDefinition {\n  try {\n    assertDatasetDefinition(value, (message) => new Error(message))\n    return true\n  } catch {\n    return false\n  }\n}\n\nexport function getDatasetRowValidationError(\n  row: unknown,\n  dataset: DatasetDefinition,\n  options?: { readonly columns?: Iterable<string> }\n): string | null {\n  if (!isPlainRecord(row)) {\n    return `Dataset '${dataset.id}' rows must be plain objects.`\n  }\n\n  const columnsByName = new Map(\n    dataset.schema.columns.map((column) => [column.name, column] as const)\n  )\n\n  // When `columns` is provided, validate only that subset (e.g. the columns a\n  // projection actually maps). Projection reads are column-pruned, so the row\n  // never carries unmapped columns and must not be checked against them.\n  if (options?.columns !== undefined) {\n    const columnsToValidate = new Set(options.columns)\n    for (const column of dataset.schema.columns) {\n      if (!columnsToValidate.has(column.name)) {\n        continue\n      }\n\n      const error = getColumnValidationError(row, column, dataset)\n      if (error) {\n        return error\n      }\n    }\n\n    return null\n  }\n\n  for (const columnName of Object.keys(row)) {\n    if (!columnsByName.has(columnName)) {\n      return `Dataset '${dataset.id}' row contains unknown column '${columnName}'.`\n    }\n  }\n\n  for (const column of dataset.schema.columns) {\n    const error = getColumnValidationError(row, column, dataset)\n    if (error) {\n      return error\n    }\n  }\n\n  return null\n}\n\nfunction getColumnValidationError(\n  row: Record<string, unknown>,\n  column: DatasetColumnDefinition,\n  dataset: DatasetDefinition\n): string | null {\n  const hasValue = Object.hasOwn(row, column.name)\n  const value = row[column.name]\n\n  // Treat `undefined` the same as an omitted field so callers either send a real\n  // value or use `null` explicitly on nullable columns.\n  if (!hasValue || value === undefined) {\n    if (!column.nullable) {\n      return `Dataset '${dataset.id}' row is missing required column '${column.name}'.`\n    }\n    return null\n  }\n\n  if (value === null) {\n    if (!column.nullable) {\n      return `Dataset '${dataset.id}' column '${column.name}' does not allow null values.`\n    }\n    return null\n  }\n\n  if (!matchesColumnType(value, column.type)) {\n    return `Dataset '${dataset.id}' column '${column.name}' must match type '${column.type}'.`\n  }\n\n  return null\n}\n",
+    "import { DatasetValidationError } from \"./errors\"\nimport type {\n  DatasetColumnDefinition,\n  DatasetColumnNameOf,\n  DatasetColumnType,\n  DatasetDefinition,\n  DatasetPrimaryKey,\n} from \"./types\"\nimport { assertDatasetColumnDefinition, assertDatasetDefinition } from \"./validation\"\n\ntype DatasetColumnOptions = {\n  readonly nullable?: boolean\n}\n\ntype DefineDatasetOptions = {\n  readonly schema: readonly DatasetColumnDefinition[]\n  readonly primaryKey?: DatasetPrimaryKey\n  readonly partitionBy?: readonly string[]\n  readonly description?: string\n}\n\ntype DeriveDatasetOptions<TParent extends DatasetDefinition> = {\n  readonly pick?: readonly DatasetColumnNameOf<TParent>[]\n  readonly add?: readonly DatasetColumnDefinition[]\n  readonly primaryKey?: DatasetPrimaryKey\n  readonly partitionBy?: readonly string[]\n  readonly description?: string\n}\n\ntype FieldFromOptions<TOptions, TKey extends string, TFallback> = TOptions extends {\n  readonly [K in TKey]: infer TValue\n}\n  ? TValue extends TFallback\n    ? { readonly [K in TKey]: TValue }\n    : { readonly [K in TKey]?: TFallback }\n  : { readonly [K in TKey]?: TFallback }\n\ntype ColumnNameOf<TColumns extends readonly DatasetColumnDefinition[]> = TColumns[number][\"name\"]\n\ntype ColumnDefinitionOf<\n  TColumns extends readonly DatasetColumnDefinition[],\n  TName extends ColumnNameOf<TColumns>,\n> = Extract<TColumns[number], { readonly name: TName }>\n\ntype PrimaryKeyColumnNameOf<TColumns extends readonly DatasetColumnDefinition[]> =\n  string extends ColumnNameOf<TColumns>\n    ? string\n    : {\n        [TName in ColumnNameOf<TColumns>]: ColumnDefinitionOf<\n          TColumns,\n          TName\n        >[\"type\"] extends \"string\"\n          ? ColumnDefinitionOf<TColumns, TName> extends { readonly nullable: true }\n            ? never\n            : TName\n          : never\n      }[ColumnNameOf<TColumns>]\n\ntype CheckedDefineDatasetOptions<TOptions extends DefineDatasetOptions> = TOptions & {\n  readonly primaryKey?: DatasetPrimaryKey<PrimaryKeyColumnNameOf<TOptions[\"schema\"]>>\n}\n\ntype PickColumns<\n  TColumns extends readonly DatasetColumnDefinition[],\n  TNames extends readonly ColumnNameOf<TColumns>[],\n> = TNames extends readonly [infer THead, ...infer TTail]\n  ? THead extends ColumnNameOf<TColumns>\n    ? TTail extends readonly ColumnNameOf<TColumns>[]\n      ? readonly [ColumnDefinitionOf<TColumns, THead>, ...PickColumns<TColumns, TTail>]\n      : never\n    : never\n  : TNames extends readonly []\n    ? readonly []\n    : readonly ColumnDefinitionOf<TColumns, TNames[number]>[]\n\ntype AddColumns<\n  TColumns extends readonly DatasetColumnDefinition[],\n  TAdd extends readonly DatasetColumnDefinition[],\n> = readonly [...TColumns, ...TAdd]\n\ntype DerivedBaseColumns<\n  TParent extends DatasetDefinition,\n  TOptions extends DeriveDatasetOptions<TParent> | undefined,\n> = TOptions extends { readonly pick: infer TPick }\n  ? TPick extends readonly DatasetColumnNameOf<TParent>[]\n    ? PickColumns<TParent[\"schema\"][\"columns\"], TPick>\n    : TParent[\"schema\"][\"columns\"]\n  : TParent[\"schema\"][\"columns\"]\n\ntype DerivedColumns<\n  TParent extends DatasetDefinition,\n  TOptions extends DeriveDatasetOptions<TParent> | undefined,\n> = TOptions extends { readonly add: infer TAdd }\n  ? TAdd extends readonly DatasetColumnDefinition[]\n    ? AddColumns<DerivedBaseColumns<TParent, TOptions>, TAdd>\n    : DerivedBaseColumns<TParent, TOptions>\n  : DerivedBaseColumns<TParent, TOptions>\n\ntype DatasetColumnResult<\n  TName extends string,\n  TType extends DatasetColumnType,\n  TOptions extends DatasetColumnOptions | undefined,\n> = {\n  readonly name: TName\n  readonly type: TType\n} & FieldFromOptions<TOptions, \"nullable\", boolean>\n\ntype DatasetDefinitionResult<TId extends string, TOptions extends DefineDatasetOptions> = Omit<\n  DatasetDefinition<TId, TOptions[\"schema\"]>,\n  \"primaryKey\" | \"partitionBy\" | \"description\"\n> &\n  FieldFromOptions<TOptions, \"primaryKey\", DatasetPrimaryKey> &\n  FieldFromOptions<TOptions, \"partitionBy\", readonly string[]> &\n  FieldFromOptions<TOptions, \"description\", string>\n\ntype DerivedDatasetDefinitionResult<\n  TId extends string,\n  TParent extends DatasetDefinition,\n  TOptions extends DeriveDatasetOptions<TParent> | undefined,\n> = Omit<\n  DatasetDefinition<TId, DerivedColumns<TParent, TOptions>>,\n  \"primaryKey\" | \"partitionBy\" | \"description\"\n> &\n  FieldFromOptions<TOptions, \"primaryKey\", DatasetPrimaryKey> &\n  FieldFromOptions<TOptions, \"partitionBy\", readonly string[]> &\n  FieldFromOptions<TOptions, \"description\", string>\n\ntype CheckedDeriveDatasetOptions<\n  TParent extends DatasetDefinition,\n  TOptions extends DeriveDatasetOptions<TParent>,\n> = TOptions & {\n  readonly primaryKey?: DatasetPrimaryKey<PrimaryKeyColumnNameOf<DerivedColumns<TParent, TOptions>>>\n}\n\nexport function col<const TName extends string, const TType extends DatasetColumnType>(\n  name: TName,\n  type: TType\n): DatasetColumnResult<TName, TType, undefined>\nexport function col<\n  const TName extends string,\n  const TType extends DatasetColumnType,\n  const TOptions extends DatasetColumnOptions,\n>(name: TName, type: TType, options: TOptions): DatasetColumnResult<TName, TType, TOptions>\nexport function col(\n  name: string,\n  type: DatasetColumnType,\n  options?: DatasetColumnOptions\n): DatasetColumnDefinition {\n  const column: DatasetColumnDefinition = {\n    name,\n    type,\n    ...(options?.nullable !== undefined ? { nullable: options.nullable } : {}),\n  }\n\n  assertDatasetColumnDefinition(column, (message) => new DatasetValidationError(message))\n  return column\n}\n\nfunction assertDatasetId(id: string): void {\n  if (!id.trim()) {\n    throw new DatasetValidationError(\"Dataset id must not be empty.\")\n  }\n}\n\nfunction createDatasetDefinition(id: string, options: DefineDatasetOptions): DatasetDefinition {\n  const definition: unknown = {\n    kind: \"dataset\",\n    id,\n    schema: {\n      columns: [...options.schema],\n    },\n    ...(options.primaryKey !== undefined\n      ? {\n          primaryKey: Array.isArray(options.primaryKey)\n            ? [...options.primaryKey]\n            : options.primaryKey,\n        }\n      : {}),\n    ...(options.partitionBy !== undefined ? { partitionBy: [...options.partitionBy] } : {}),\n    ...(options.description !== undefined ? { description: options.description } : {}),\n  }\n\n  assertDatasetDefinition(definition, (message) => new DatasetValidationError(message))\n  return definition\n}\n\nfunction assertStringArray(value: unknown, field: string): asserts value is readonly string[] {\n  if (!Array.isArray(value)) {\n    throw new DatasetValidationError(`${field} must be an array of column names.`)\n  }\n\n  for (const item of value) {\n    if (typeof item !== \"string\" || !item.trim()) {\n      throw new DatasetValidationError(`${field} must contain only non-empty column names.`)\n    }\n  }\n}\n\nfunction deriveDatasetDefinition(\n  id: string,\n  parent: DatasetDefinition,\n  options: DeriveDatasetOptions<DatasetDefinition> = {}\n): DatasetDefinition {\n  assertDatasetDefinition(parent, (message) => new DatasetValidationError(message))\n\n  if (options.pick !== undefined) {\n    assertStringArray(options.pick, \"Dataset derive pick\")\n  }\n\n  if (options.add !== undefined && !Array.isArray(options.add)) {\n    throw new DatasetValidationError(\"Dataset derive add must be an array of columns.\")\n  }\n\n  const parentColumnsByName = new Map(\n    parent.schema.columns.map((column) => [column.name, column] as const)\n  )\n  const pickedColumns =\n    options.pick === undefined\n      ? parent.schema.columns\n      : options.pick.map((columnName) => {\n          const column = parentColumnsByName.get(columnName)\n          if (column === undefined) {\n            throw new DatasetValidationError(\n              `Dataset derive pick column '${columnName}' is not declared on parent dataset '${parent.id}'.`\n            )\n          }\n          return column\n        })\n\n  return createDatasetDefinition(id, {\n    schema: [...pickedColumns, ...(options.add ?? [])],\n    ...(options.primaryKey !== undefined ? { primaryKey: options.primaryKey } : {}),\n    ...(options.partitionBy !== undefined ? { partitionBy: options.partitionBy } : {}),\n    ...(options.description !== undefined ? { description: options.description } : {}),\n  })\n}\n\nfunction createDatasetDeriveBuilder<TId extends string>(id: TId) {\n  assertDatasetId(id)\n\n  function derive<const TParent extends DatasetDefinition>(\n    parent: TParent\n  ): DerivedDatasetDefinitionResult<TId, TParent, undefined>\n  function derive<\n    const TParent extends DatasetDefinition,\n    const TOptions extends DeriveDatasetOptions<TParent>,\n  >(\n    parent: TParent,\n    options: CheckedDeriveDatasetOptions<TParent, TOptions>\n  ): DerivedDatasetDefinitionResult<TId, TParent, TOptions>\n  function derive(\n    parent: DatasetDefinition,\n    options?: DeriveDatasetOptions<DatasetDefinition>\n  ): DatasetDefinition {\n    return deriveDatasetDefinition(id, parent, options)\n  }\n\n  return { derive }\n}\n\nexport function defineDataset<const TId extends string>(\n  id: TId\n): ReturnType<typeof createDatasetDeriveBuilder<TId>>\nexport function defineDataset<\n  const TId extends string,\n  const TOptions extends DefineDatasetOptions,\n>(id: TId, options: CheckedDefineDatasetOptions<TOptions>): DatasetDefinitionResult<TId, TOptions>\nexport function defineDataset(\n  id: string,\n  options?: DefineDatasetOptions\n): DatasetDefinition | ReturnType<typeof createDatasetDeriveBuilder<string>> {\n  if (options === undefined) {\n    return createDatasetDeriveBuilder(id)\n  }\n\n  return createDatasetDefinition(id, options)\n}\n",
+    "export type MergeChange<Row, Key> =\n  | { readonly kind: \"upsert\"; readonly row: Row }\n  | { readonly kind: \"delete\"; readonly key: Key }\n\nexport const change = {\n  upsert<const Row extends object>(row: Row): { readonly kind: \"upsert\"; readonly row: Row } {\n    return { kind: \"upsert\", row }\n  },\n\n  delete<const Key extends object>(key: Key): { readonly kind: \"delete\"; readonly key: Key } {\n    return { kind: \"delete\", key }\n  },\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "5BD3A97C32D4B31E64756E2164756E21",
+  "names": []
+}

package/dist/chunk-bct7hmfc.js

@@ -0,0 +1,402 @@
+// @bun
+import {
+  isOAuthConnectorDefinition
+} from "./chunk-8m5ejdpn.js";
+import {
+  createPrimitiveExecutionRecord,
+  ensureExecutionRecord,
+  executionRecordInputFromRuntime
+} from "./chunk-8ryen3p3.js";
+import {
+  SYNC_RUN_FAILURE_CODES
+} from "./chunk-ys1nse2v.js";
+import {
+  SyncRunError
+} from "./chunk-62c7t4jc.js";
+import {
+  ConnectorConnectionStorageError
+} from "./chunk-5gd7tpv6.js";
+import {
+  reportRunFailure
+} from "./chunk-dsrkgtnh.js";
+import {
+  AuthorizationError,
+  assertAuthorized,
+  assertProviderAccess,
+  resolveExecutionScopeAuthorization
+} from "./chunk-34bqh420.js";
+import {
+  createSixbError,
+  isSixbError,
+  toSixbFailure
+} from "./chunk-0172wgm9.js";
+
+// src/connectors/errors.ts
+class ConnectorError extends Error {
+  name = "ConnectorError";
+}
+
+class ConnectorNotFoundError extends ConnectorError {
+  connectorId;
+  name = "ConnectorNotFoundError";
+  constructor(connectorId) {
+    super(`Unknown connector '${connectorId}'`);
+    this.connectorId = connectorId;
+  }
+}
+
+class ConnectorOAuthError extends ConnectorError {
+  kind;
+  name = "ConnectorOAuthError";
+  constructor(kind, message, options) {
+    super(message, options);
+    this.kind = kind;
+  }
+}
+function createConnectorCodedError(code, message, options = {}) {
+  return createSixbError(code, message.startsWith("[Sixb]") ? message : `[Sixb] ${message}`, options);
+}
+function createAmbiguousProviderOperationError(options = {}) {
+  return createConnectorCodedError("connector.provider_failed", "Connector provider operation outcome is ambiguous.", options);
+}
+function oauthErrorKind(error) {
+  return error instanceof ConnectorOAuthError ? error.kind : "ambiguous";
+}
+function providerFailureCode(error) {
+  return oauthErrorKind(error) === "retryable" ? "connector.provider_unavailable" : "connector.provider_failed";
+}
+function providerBoundaryError(error, code, message) {
+  if (isSixbError(error) && error.code.startsWith("connector."))
+    return error;
+  return createConnectorCodedError(code, message, { cause: error });
+}
+function isConnectorStorageError(error, code) {
+  return error instanceof ConnectorConnectionStorageError && (code === undefined || error.code === code);
+}
+function storageBoundaryError(error, message) {
+  return createConnectorCodedError("internal.unexpected", message, { cause: error });
+}
+async function recoverConnectorFailure(primaryError, message, recovery) {
+  try {
+    return await recovery();
+  } catch (recoveryError) {
+    throw createConnectorCodedError("internal.unexpected", message, {
+      cause: new AggregateError([primaryError, recoveryError], message)
+    });
+  }
+}
+
+// src/syncs/errors.ts
+class SyncValidationError extends Error {
+  name = "SyncValidationError";
+}
+
+// src/syncs/run-dispatch.ts
+import { randomUUID } from "crypto";
+class SyncRunDispatcher {
+  dependencies;
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async dispatch(input) {
+    assertAutomaticDispatchInput(input);
+    const sync = this.dependencies.definitions.syncs.getById(input.syncId);
+    if (!sync)
+      throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`);
+    return dispatchSyncRun({
+      errorReporterHost: this.dependencies,
+      projectId: this.dependencies.id,
+      sync,
+      storage: this.dependencies.storage,
+      queue: this.dependencies.queues.syncRuns,
+      runId: input.runId,
+      expectedLatestVersionId: input.expectedLatestVersionId,
+      commitMessage: input.commitMessage,
+      metadata: input.metadata,
+      validateExistingRun: (run, storage) => assertAutomaticExecutionIdentity(storage, this.dependencies.id, input, run),
+      createExecution: async (executionId, runId) => createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "sync", id: sync.id, runId },
+        origin: {
+          type: "automatic",
+          projectId: this.dependencies.id,
+          source: input.source,
+          correlationId: input.correlationId
+        }
+      })
+    });
+  }
+}
+async function dispatchSyncRun(input) {
+  const runId = createSyncRunId(input.runId);
+  const persisted = await persistSyncRun(input, runId);
+  if (!persisted.publish)
+    return existingSyncRunResult(persisted.run);
+  return publishSyncRun(input, persisted);
+}
+async function persistSyncRun(input, runId) {
+  const syncRuns = requireSyncRunStorage(input.storage);
+  const existing = await syncRuns.getById({ projectId: input.projectId, id: runId });
+  if (existing)
+    return reuseSyncRun(input, existing);
+  const execution = await input.createExecution(`exec_${randomUUID()}`, runId);
+  const queuedAt = new Date;
+  try {
+    return await input.storage.transaction(async (tx) => {
+      const transactionalRuns = requireSyncRunStorage(tx);
+      const raced = await transactionalRuns.getById({ projectId: input.projectId, id: runId });
+      if (raced) {
+        assertExistingRunMatchesRequest(raced, input);
+        await input.validateExistingRun?.(raced, tx);
+        return { publish: false, run: raced };
+      }
+      await tx.executions.create(execution);
+      const run = await transactionalRuns.queue({
+        projectId: input.projectId,
+        id: runId,
+        executionId: execution.id,
+        syncId: input.sync.id,
+        datasetId: input.sync.target.dataset.id,
+        mode: input.sync.config.mode,
+        queuedAt,
+        expectedLatestVersionId: input.expectedLatestVersionId,
+        commitMessage: input.commitMessage
+      });
+      return { publish: true, run, execution, queuedAt, created: true };
+    }, { isolation: "serializable" });
+  } catch (error) {
+    if (!(error instanceof SyncRunError))
+      throw error;
+    const raced = await syncRuns.getById({ projectId: input.projectId, id: runId });
+    if (!raced)
+      throw error;
+    assertExistingRunMatchesRequest(raced, input);
+    await input.validateExistingRun?.(raced, input.storage);
+    return { publish: false, run: raced };
+  }
+}
+async function reuseSyncRun(input, existing) {
+  assertExistingRunMatchesRequest(existing, input);
+  await input.validateExistingRun?.(existing, input.storage);
+  if (existing.status !== "failed" || existing.error?.code !== "queue.enqueue_failed" || !existing.error.retryable) {
+    return { publish: false, run: existing };
+  }
+  const execution = await input.storage.executions.getById({
+    projectId: input.projectId,
+    id: existing.executionId
+  });
+  if (!execution) {
+    throw new SyncRunError(`[Sixb] Execution '${existing.executionId}' for Sync run '${existing.id}' was not found.`);
+  }
+  const queuedAt = new Date;
+  const run = await requireSyncRunStorage(input.storage).queue({
+    projectId: input.projectId,
+    id: existing.id,
+    executionId: existing.executionId,
+    syncId: existing.syncId,
+    datasetId: existing.datasetId,
+    mode: existing.mode,
+    queuedAt,
+    expectedLatestVersionId: existing.expectedLatestVersionId,
+    commitMessage: existing.commitMessage
+  });
+  return { publish: true, run, execution, queuedAt, created: false };
+}
+async function publishSyncRun(input, persisted) {
+  try {
+    const [job] = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: [
+        {
+          id: persisted.run.id,
+          type: "sync.run.requested",
+          payload: { runId: persisted.run.id },
+          ...input.metadata === undefined ? {} : { metadata: input.metadata }
+        }
+      ]
+    });
+    return {
+      syncId: persisted.run.syncId,
+      runId: persisted.run.id,
+      queuedAt: persisted.queuedAt.toISOString(),
+      ...job?.id ? { jobId: job.id } : {},
+      created: persisted.created
+    };
+  } catch (error) {
+    const failedAt = new Date;
+    const failure = toEnqueueFailure(error, persisted.run, failedAt);
+    const failed = await requireSyncRunStorage(input.storage).finish({
+      projectId: input.projectId,
+      id: persisted.run.id,
+      status: "failed",
+      finishedAt: failedAt,
+      error: failure
+    });
+    reportRunFailure(input.errorReporterHost, error, {
+      projectId: input.projectId,
+      runKind: "sync",
+      run: { runId: failed.id, syncId: failed.syncId },
+      failure
+    });
+    throw error;
+  }
+}
+function assertExistingRunMatchesRequest(existing, input) {
+  if (existing.syncId !== input.sync.id || existing.datasetId !== input.sync.target.dataset.id || existing.mode !== input.sync.config.mode || existing.expectedLatestVersionId !== input.expectedLatestVersionId || existing.commitMessage !== input.commitMessage) {
+    throw new SyncRunError(`[Sixb] Sync run '${existing.id}' already exists with a different request payload.`);
+  }
+}
+function existingSyncRunResult(existing) {
+  return {
+    syncId: existing.syncId,
+    runId: existing.id,
+    queuedAt: existing.queuedAt.toISOString(),
+    created: false
+  };
+}
+function requireSyncRunStorage(storage) {
+  if (!storage.syncRuns)
+    throw new SyncValidationError("[Sixb] Sync run storage is not configured.");
+  return storage.syncRuns;
+}
+function createSyncRunId(runId) {
+  if (runId === undefined)
+    return `run_${randomUUID()}`;
+  if (!runId.trim())
+    throw new SyncValidationError("[Sixb] Sync run id must not be empty");
+  return runId;
+}
+function assertAutomaticDispatchInput(input) {
+  assertNonBlank(input.syncId, "Sync id");
+  assertNonBlank(input.runId, "Sync run id");
+  assertNonBlank(input.source.eventId, "Sync source event id");
+  assertNonBlank(input.correlationId, "Sync correlation id");
+}
+async function assertAutomaticExecutionIdentity(storage, projectId, input, run) {
+  const execution = await storage.executions.getById({ projectId, id: run.executionId });
+  if (!execution || execution.source.type !== input.source.type || execution.source.eventId !== input.source.eventId || execution.correlationId !== input.correlationId || execution.requestedBy !== undefined) {
+    throw new SyncValidationError(`[Sixb] Sync run '${run.id}' already exists with different automatic provenance.`);
+  }
+}
+function toEnqueueFailure(error, run, at) {
+  const enqueueError = createSixbError("queue.enqueue_failed", `[Sixb] Could not enqueue Sync run '${run.id}'.`, {
+    cause: error,
+    details: { syncId: run.syncId, runId: run.id, phase: "enqueue" }
+  });
+  return toSixbFailure(enqueueError, { allowedCodes: SYNC_RUN_FAILURE_CODES, at });
+}
+function assertNonBlank(value, label) {
+  if (!value.trim())
+    throw new SyncValidationError(`[Sixb] ${label} must not be empty.`);
+}
+
+// src/syncs/request.ts
+async function requestSyncRun(runtime, execution, sync, options = {}) {
+  assertAuthorized(runtime, { kind: "sync.run", syncId: sync.id });
+  if (!runtime.storage.syncRuns) {
+    throw new SyncValidationError("[Sixb] Sync run storage is not configured.");
+  }
+  const queue = runtime.queues.syncRuns;
+  if (!queue) {
+    throw new SyncValidationError("[Sixb] Sync run queue is not configured.");
+  }
+  return dispatchSyncRun({
+    errorReporterHost: runtime,
+    projectId: runtime.projectId,
+    sync,
+    storage: runtime.storage,
+    queue,
+    ...options,
+    createExecution: async (executionId, runId) => {
+      const caller = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
+        execution,
+        runtimeAuthorization: runtime.runtimeAuthorization
+      }));
+      return createPrimitiveExecutionRecord({
+        id: executionId,
+        primitive: { kind: "sync", id: sync.id, runId },
+        origin: { type: "execution", parent: caller }
+      });
+    }
+  });
+}
+
+// src/connectors/execution.ts
+var sourceResolvers = new WeakMap;
+function createConnectorRuntime(runtime, execution, service) {
+  const connector = (definition, selector) => {
+    if (isOAuthConnectorDefinition(definition)) {
+      assertConnectorConnectionAccess(runtime, execution);
+      if (!selector) {
+        throw createConnectorCodedError("connector.configuration_invalid", `[Sixb] Connector '${definition.id}' uses persistent connections and requires an explicit owner and slot.`);
+      }
+      return service.connectConnection(definition, selector);
+    }
+    if (selector) {
+      throw createConnectorCodedError("connector.configuration_invalid", `[Sixb] Static connector '${definition.id}' does not accept a connection.`);
+    }
+    assertProviderAccess(runtime, execution, "connector.connect");
+    return service.connect(definition);
+  };
+  registerConnectorExecutionSourceResolver(connector, {
+    async list(definition) {
+      if (!isOAuthConnectorDefinition(definition)) {
+        return [
+          {
+            connect: (_signal) => connector(definition)
+          }
+        ];
+      }
+      assertConnectorConnectionAccess(runtime, execution);
+      const connections = await service.listExecutionConnections(definition);
+      return connections.map((connection) => ({
+        connection: {
+          id: connection.id,
+          connectorId: connection.connectorId,
+          owner: connection.owner,
+          slot: connection.slot,
+          account: connection.account
+        },
+        connect: (signal) => service.connectExecutionConnection(definition, connection, signal)
+      }));
+    }
+  });
+  return connector;
+}
+function registerConnectorExecutionSourceResolver(connector, resolver) {
+  const registered = sourceResolvers.get(connector);
+  if (registered && registered !== resolver) {
+    throw new Error("[Sixb] Connector source resolver is already registered for this execution.");
+  }
+  sourceResolvers.set(connector, resolver);
+}
+function getConnectorExecutionSourceResolver(connector) {
+  const resolver = sourceResolvers.get(connector);
+  if (resolver)
+    return resolver;
+  return {
+    async list(definition) {
+      if (isOAuthConnectorDefinition(definition)) {
+        throw createConnectorCodedError("connector.configuration_invalid", `[Sixb] OAuth connector '${definition.id}' cannot be resolved without the managed connection runtime.`);
+      }
+      return [
+        {
+          connect: (_signal) => connector(definition)
+        }
+      ];
+    }
+  };
+}
+function assertConnectorConnectionAccess(runtime, execution) {
+  const resolved = resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization
+  });
+  if (resolved.type === "unrestricted" && resolved.ref.type === "trustedPrimitive")
+    return;
+  throw new AuthorizationError("privileged:connector-connection.connect", "[Sixb] Connector connection clients are restricted to trusted primitive executions.");
+}
+
+export { ConnectorError, ConnectorNotFoundError, ConnectorOAuthError, createConnectorCodedError, createAmbiguousProviderOperationError, oauthErrorKind, providerFailureCode, providerBoundaryError, isConnectorStorageError, storageBoundaryError, recoverConnectorFailure, createConnectorRuntime, getConnectorExecutionSourceResolver, SyncValidationError, SyncRunDispatcher, requestSyncRun };
+
+//# debugId=ED1A30ED8A438D8864756E2164756E21