@metabase/client 0.0.0-stage → 0.1.1

package/dist/domain/transform.js

@@ -0,0 +1,304 @@
+import { z } from "zod";
+//#region src/domain/transform.ts
+const TransformSourceType = z.enum([
+	"native",
+	"mbql",
+	"python"
+]);
+const TransformRunStatus = z.enum([
+	"started",
+	"succeeded",
+	"failed",
+	"timeout",
+	"canceled",
+	"canceling"
+]);
+const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+	"succeeded",
+	"failed",
+	"timeout",
+	"canceled"
+]);
+const FAILURE_STATUSES = /* @__PURE__ */ new Set([
+	"failed",
+	"timeout",
+	"canceled"
+]);
+/** Whether the server will report any further progress for a run in this status. */
+function isTransformRunTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+/** Whether a terminal status means the run did not produce its target table. */
+function isTransformRunFailed(status) {
+	return FAILURE_STATUSES.has(status);
+}
+const TransformRunMethod = z.enum(["manual", "cron"]);
+const TransformRunTrigger = z.enum(["none", "global-schedule"]);
+const TransformCheckpointStrategy = z.object({
+	type: z.literal("checkpoint"),
+	"checkpoint-filter-field-id": z.number().int().positive().optional()
+}).loose();
+const TransformSourceTableRefInput = z.object({
+	alias: z.string(),
+	database_id: z.number().int(),
+	schema: z.string().nullable().optional(),
+	table: z.string().optional(),
+	table_id: z.number().int().nullable().optional()
+}).loose();
+const TransformSourceTableIdInput = z.object({
+	alias: z.string(),
+	table_id: z.number().int(),
+	database_id: z.null().optional(),
+	schema: z.null().optional(),
+	table: z.null().optional()
+}).loose();
+const TransformSourceTableEntryInput = z.union([TransformSourceTableRefInput, TransformSourceTableIdInput]);
+function namesTableByIdAlone(entry) {
+	return typeof entry.database_id !== "number";
+}
+const TransformSourceTableEntry = TransformSourceTableRefInput.extend({
+	database_id: z.number().int().nullable().optional(),
+	schema: z.string().nullable().optional(),
+	table: z.string().nullable().optional()
+});
+const TransformQuerySource = z.object({
+	type: z.literal("query"),
+	query: z.unknown().describe("Native SQL or MBQL query"),
+	"source-incremental-strategy": TransformCheckpointStrategy.optional()
+}).loose();
+const TransformPythonSource = z.object({
+	type: z.literal("python"),
+	body: z.string(),
+	"source-tables": z.array(TransformSourceTableEntry),
+	"source-database": z.number().int().optional(),
+	"source-incremental-strategy": TransformCheckpointStrategy.optional()
+}).loose();
+const TransformSource = z.discriminatedUnion("type", [TransformQuerySource, TransformPythonSource]);
+const TransformSourceTableRefWireV59 = z.object({
+	database_id: z.number().int(),
+	schema: z.string().nullable().optional(),
+	table: z.string(),
+	table_id: z.number().int().nullable().optional()
+}).loose();
+const TransformSourceTableWireV59 = z.union([
+	z.number().int(),
+	z.null(),
+	TransformSourceTableRefWireV59
+]);
+const TransformSourceTablesWireV59 = z.record(z.string(), TransformSourceTableWireV59);
+function toSourceTableEntry(alias, wire) {
+	if (wire === null || typeof wire === "number") return {
+		alias,
+		table_id: wire,
+		database_id: null,
+		schema: null,
+		table: null
+	};
+	return {
+		...wire,
+		alias
+	};
+}
+function fromAliasMap(wire) {
+	return Object.entries(wire).map(([alias, value]) => toSourceTableEntry(alias, value));
+}
+const TransformPythonSourceWireV59 = TransformPythonSource.extend({ "source-tables": TransformSourceTablesWireV59.transform(fromAliasMap) });
+const TransformSourceWireV59 = z.discriminatedUnion("type", [TransformQuerySource, TransformPythonSourceWireV59]);
+function transformSourceSchema(features) {
+	return features.transformSourceTablesAsList ? TransformSource : TransformSourceWireV59;
+}
+const TransformPythonSourceInput = TransformPythonSource.extend({ "source-tables": z.array(TransformSourceTableEntryInput) });
+const TransformSourceInput = z.discriminatedUnion("type", [TransformQuerySource, TransformPythonSourceInput]);
+function toAliasMapValue(entry) {
+	const { alias: _alias, ...reference } = entry;
+	return namesTableByIdAlone(entry) ? entry.table_id : reference;
+}
+/** Each entry keyed by its alias, its value chosen by `value`, as a server without the list reads it. */
+function keyedByAlias(entries, value) {
+	return Object.fromEntries(entries.map((entry) => [entry.alias, value(entry)]));
+}
+/** A transform body's `source` as a server with `features` reads it. */
+function transformSourceBody(source, features) {
+	if (features.transformSourceTablesAsList || source.type !== "python") return source;
+	return {
+		...source,
+		"source-tables": keyedByAlias(source["source-tables"], toAliasMapValue)
+	};
+}
+const TransformAppendStrategy = z.object({ type: z.literal("append") }).loose();
+const TransformMergeKeyColumn = z.object({
+	name: z.string().min(1).optional(),
+	"field-id": z.number().int().positive().nullable().optional()
+}).loose();
+const TransformMergeStrategy = z.object({
+	type: z.literal("merge"),
+	"unique-key": z.array(TransformMergeKeyColumn)
+}).loose();
+const TransformTargetIncrementalStrategy = z.discriminatedUnion("type", [TransformAppendStrategy, TransformMergeStrategy]);
+const TransformTableTarget = z.object({
+	type: z.literal("table"),
+	database: z.number().int().optional(),
+	schema: z.string().min(1).nullable().optional(),
+	name: z.string()
+}).loose();
+const TransformTableIncrementalTarget = z.object({
+	type: z.literal("table-incremental"),
+	database: z.number().int().optional(),
+	schema: z.string().min(1).nullable().optional(),
+	name: z.string(),
+	"target-incremental-strategy": TransformTargetIncrementalStrategy
+}).loose();
+const TransformTarget = z.discriminatedUnion("type", [TransformTableTarget, TransformTableIncrementalTarget]);
+const TransformTargetCompact = z.discriminatedUnion("type", [TransformTableTarget.strip(), TransformTableIncrementalTarget.strip()]);
+const TransformLastRun = z.object({
+	id: z.number().int(),
+	transform_id: z.number().int(),
+	run_method: TransformRunMethod,
+	status: TransformRunStatus,
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRun = z.object({
+	id: z.number().int(),
+	transform_id: z.number().int().nullable(),
+	run_method: TransformRunMethod,
+	status: TransformRunStatus,
+	is_active: z.boolean().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRunCompact = TransformRun.pick({
+	id: true,
+	transform_id: true,
+	status: true,
+	run_method: true,
+	start_time: true,
+	end_time: true,
+	message: true
+}).strip();
+const TransformRunResult = z.object({
+	message: z.string(),
+	run_id: z.number().int().positive().nullable(),
+	final: TransformRun.nullable(),
+	target_table_id: z.number().int().nullable().optional()
+});
+/** Which transforms a DAG reprocess from a seed transform runs, besides the seed itself. */
+const TransformDagDirection = z.enum(["upstream", "downstream"]);
+const TransformDagRunResult = z.object({
+	message: z.string(),
+	dag_run_id: z.number().int().positive().nullable()
+});
+const TransformDagTransform = z.object({
+	id: z.number().int(),
+	name: z.string()
+});
+const TransformRunSummaryType = z.enum([
+	"job",
+	"dag",
+	"transform"
+]);
+const TransformRunSummarySortColumn = z.enum(["start_time", "end_time"]);
+const TransformRunSummary = z.object({
+	run_type: TransformRunSummaryType,
+	id: z.number().int(),
+	entity_id: z.number().int().nullable(),
+	name: z.string().nullable(),
+	direction: TransformDagDirection.nullable(),
+	transform_count: z.number().int().nullable(),
+	run_method: TransformRunMethod.nullable(),
+	status: TransformRunStatus,
+	is_active: z.boolean().nullable(),
+	start_time: z.string(),
+	end_time: z.string().nullable().optional(),
+	message: z.string().nullable(),
+	user_id: z.number().int().nullable()
+}).loose();
+const TransformRunSummaryCompact = TransformRunSummary.pick({
+	run_type: true,
+	id: true,
+	entity_id: true,
+	name: true,
+	status: true,
+	run_method: true,
+	start_time: true,
+	end_time: true,
+	message: true
+}).strip();
+const TransformBase = z.object({
+	id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	source: TransformSource,
+	target: TransformTarget,
+	source_type: TransformSourceType,
+	source_database_id: z.number().int().nullable().optional(),
+	target_db_id: z.number().int().nullable().optional(),
+	entity_id: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string(),
+	creator_id: z.number().int(),
+	collection_id: z.number().int().nullable(),
+	run_trigger: TransformRunTrigger.nullable().optional(),
+	last_run: TransformLastRun.nullable().optional(),
+	tag_ids: z.array(z.number().int()).optional()
+}).loose();
+const Transform = TransformBase.extend({ target_table_id: z.number().int().nullable() });
+const TransformWireV59Detail = TransformBase.extend({ table: z.object({ id: z.number().int() }).loose().nullable() });
+function fromHydratedTable(wire) {
+	return {
+		...wire,
+		target_table_id: wire.table === null ? null : wire.table.id
+	};
+}
+function withoutLink(row) {
+	return {
+		...row,
+		target_table_id: null
+	};
+}
+/** The shape `GET /api/transform/{id}` answers on a server with `features`, read as `Transform`. */
+function transformDetailSchema(features) {
+	const source = transformSourceSchema(features);
+	return features.transformTargetTableId ? Transform.extend({ source }) : TransformWireV59Detail.extend({ source }).transform(fromHydratedTable);
+}
+/** The shape every other transform endpoint answers on a server with `features`, read as `Transform`. */
+function transformRowSchema(features) {
+	const source = transformSourceSchema(features);
+	return features.transformTargetTableId ? Transform.extend({ source }) : TransformBase.extend({ source }).transform(withoutLink);
+}
+const TransformCompact = Transform.pick({
+	id: true,
+	name: true,
+	description: true,
+	source_type: true,
+	target_db_id: true,
+	target_table_id: true
+}).strip().extend({ target: TransformTargetCompact });
+const TransformCreateInput = z.object({
+	name: z.string().min(1),
+	description: z.string().nullable().optional(),
+	source: TransformSourceInput,
+	target: TransformTarget,
+	run_trigger: TransformRunTrigger.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional(),
+	owner_email: z.string().nullable().optional()
+}).loose();
+const TransformUpdateInput = z.object({
+	name: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	source: TransformSourceInput.optional(),
+	target: TransformTarget.optional(),
+	run_trigger: TransformRunTrigger.optional(),
+	tag_ids: z.array(z.number().int().positive()).optional(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	owner_user_id: z.number().int().positive().nullable().optional(),
+	owner_email: z.string().nullable().optional()
+}).loose();
+//#endregion
+export { Transform, TransformCompact, TransformCreateInput, TransformDagDirection, TransformDagRunResult, TransformDagTransform, TransformRun, TransformRunCompact, TransformRunMethod, TransformRunResult, TransformRunStatus, TransformRunSummary, TransformRunSummaryCompact, TransformRunSummarySortColumn, TransformRunSummaryType, TransformSourceTableEntry, TransformSourceTableEntryInput, TransformTarget, TransformUpdateInput, isTransformRunFailed, isTransformRunTerminal, keyedByAlias, transformDetailSchema, transformRowSchema, transformSourceBody };

package/dist/domain/upload.d.ts

@@ -0,0 +1,2 @@
+import { n as UploadUpdateAction, r as UploadUpdateResult, t as UploadResult } from "../upload-UPfZFdbH.js";
+export { UploadResult, UploadUpdateAction, UploadUpdateResult };

package/dist/domain/upload.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region src/domain/upload.ts
+const UploadResult = z.object({
+	model_id: z.number().int(),
+	table_id: z.number().int()
+});
+const UploadUpdateAction = z.enum(["append", "replace"]);
+const UploadUpdateResult = z.object({
+	table_id: z.number().int(),
+	action: UploadUpdateAction
+});
+//#endregion
+export { UploadResult, UploadUpdateAction, UploadUpdateResult };

package/dist/domain/user.d.ts

@@ -0,0 +1,2 @@
+import { n as CurrentUserCompact, t as CurrentUser } from "../user-Sqqv7rqh.js";
+export { CurrentUser, CurrentUserCompact };

package/dist/domain/user.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+//#region src/domain/user.ts
+const CurrentUser = z.object({
+	id: z.number().int(),
+	email: z.string(),
+	common_name: z.string(),
+	is_superuser: z.boolean()
+}).loose();
+const CurrentUserCompact = CurrentUser.pick({
+	id: true,
+	email: true,
+	common_name: true,
+	is_superuser: true
+}).strip();
+//#endregion
+export { CurrentUser, CurrentUserCompact };

package/dist/eid-translation-CH6NPWd-.d.ts

@@ -0,0 +1,143 @@
+import { z } from "zod";
+//#region src/domain/eid-translation.d.ts
+declare const EID_MODELS: readonly ["action", "card", "collection", "dashboard", "dashboard-card", "dashboard-tab", "dataset", "dimension", "document", "exploration", "measure", "metric", "permissions-group", "pulse", "pulse-card", "pulse-channel", "segment", "snippet", "timeline", "transform", "user"];
+declare const EidModel: z.ZodEnum<{
+  transform: "transform";
+  collection: "collection";
+  card: "card";
+  dashboard: "dashboard";
+  dataset: "dataset";
+  document: "document";
+  metric: "metric";
+  measure: "measure";
+  pulse: "pulse";
+  segment: "segment";
+  snippet: "snippet";
+  timeline: "timeline";
+  user: "user";
+  exploration: "exploration";
+  action: "action";
+  dimension: "dimension";
+  "dashboard-card": "dashboard-card";
+  "dashboard-tab": "dashboard-tab";
+  "permissions-group": "permissions-group";
+  "pulse-card": "pulse-card";
+  "pulse-channel": "pulse-channel";
+}>;
+type EidModel = z.infer<typeof EidModel>;
+declare const EidTranslateInput: z.ZodObject<{
+  entity_ids: z.ZodRecord<z.ZodEnum<{
+    transform: "transform";
+    collection: "collection";
+    card: "card";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    segment: "segment";
+    snippet: "snippet";
+    timeline: "timeline";
+    user: "user";
+    exploration: "exploration";
+    action: "action";
+    dimension: "dimension";
+    "dashboard-card": "dashboard-card";
+    "dashboard-tab": "dashboard-tab";
+    "permissions-group": "permissions-group";
+    "pulse-card": "pulse-card";
+    "pulse-channel": "pulse-channel";
+  }> & z.core.$partial, z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+type EidTranslateInput = z.infer<typeof EidTranslateInput>;
+declare const EidTranslateEntry: z.ZodObject<{
+  status: z.ZodString;
+  type: z.ZodEnum<{
+    transform: "transform";
+    collection: "collection";
+    card: "card";
+    dashboard: "dashboard";
+    dataset: "dataset";
+    document: "document";
+    metric: "metric";
+    measure: "measure";
+    pulse: "pulse";
+    segment: "segment";
+    snippet: "snippet";
+    timeline: "timeline";
+    user: "user";
+    exploration: "exploration";
+    action: "action";
+    dimension: "dimension";
+    "dashboard-card": "dashboard-card";
+    "dashboard-tab": "dashboard-tab";
+    "permissions-group": "permissions-group";
+    "pulse-card": "pulse-card";
+    "pulse-channel": "pulse-channel";
+  }>;
+  id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+type EidTranslateEntry = z.infer<typeof EidTranslateEntry>;
+declare const EidTranslateResult: z.ZodObject<{
+  entity_ids: z.ZodRecord<z.ZodString, z.ZodObject<{
+    status: z.ZodString;
+    type: z.ZodEnum<{
+      transform: "transform";
+      collection: "collection";
+      card: "card";
+      dashboard: "dashboard";
+      dataset: "dataset";
+      document: "document";
+      metric: "metric";
+      measure: "measure";
+      pulse: "pulse";
+      segment: "segment";
+      snippet: "snippet";
+      timeline: "timeline";
+      user: "user";
+      exploration: "exploration";
+      action: "action";
+      dimension: "dimension";
+      "dashboard-card": "dashboard-card";
+      "dashboard-tab": "dashboard-tab";
+      "permissions-group": "permissions-group";
+      "pulse-card": "pulse-card";
+      "pulse-channel": "pulse-channel";
+    }>;
+    id: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+type EidTranslateResult = z.infer<typeof EidTranslateResult>;
+declare const EidTranslateResultCompact: z.ZodObject<{
+  entity_ids: z.ZodRecord<z.ZodString, z.ZodObject<{
+    status: z.ZodString;
+    type: z.ZodEnum<{
+      transform: "transform";
+      collection: "collection";
+      card: "card";
+      dashboard: "dashboard";
+      dataset: "dataset";
+      document: "document";
+      metric: "metric";
+      measure: "measure";
+      pulse: "pulse";
+      segment: "segment";
+      snippet: "snippet";
+      timeline: "timeline";
+      user: "user";
+      exploration: "exploration";
+      action: "action";
+      dimension: "dimension";
+      "dashboard-card": "dashboard-card";
+      "dashboard-tab": "dashboard-tab";
+      "permissions-group": "permissions-group";
+      "pulse-card": "pulse-card";
+      "pulse-channel": "pulse-channel";
+    }>;
+    id: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$strip>;
+type EidTranslateResultCompact = z.infer<typeof EidTranslateResultCompact>;
+//#endregion
+export { EidTranslateResult as a, EidTranslateInput as i, EidModel as n, EidTranslateResultCompact as o, EidTranslateEntry as r, EID_MODELS as t };

package/dist/embedding-oU3gqfgX.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+//#region src/domain/embedding.d.ts
+declare const EmbeddingParams: z.ZodRecord<z.ZodString, z.ZodEnum<{
+  enabled: "enabled";
+  disabled: "disabled";
+  locked: "locked";
+}>>;
+type EmbeddingParams = z.infer<typeof EmbeddingParams>;
+//#endregion
+export { EmbeddingParams as t };