@platforma-sdk/package-builder-lib 1.1.0

package/dist/core/schemas/artifacts.d.ts

@@ -0,0 +1,280 @@
+import { z } from "zod/v4";
+
+//#region src/core/schemas/artifacts.d.ts
+declare const artifactTypes: readonly ["asset", "environment", "binary", "java", "python", "R", "docker", "conda"];
+type artifactType = (typeof artifactTypes)[number];
+declare const registrySchema: z.ZodObject<{
+  name: z.ZodString;
+  downloadURL: z.ZodOptional<z.ZodString>;
+  storageURL: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type registry = z.infer<typeof registrySchema>;
+declare const assetSchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  type: z.ZodLiteral<"asset">;
+}, z.core.$strict>;
+type assetType = z.infer<typeof assetSchema>;
+declare const environmentSchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  roots: z.ZodRecord<z.ZodEnum<{
+    "linux-x64": "linux-x64";
+    "linux-aarch64": "linux-aarch64";
+    "macosx-x64": "macosx-x64";
+    "macosx-aarch64": "macosx-aarch64";
+    "windows-x64": "windows-x64";
+    "windows-aarch64": "windows-aarch64";
+  }> & z.core.$partial, z.ZodString>;
+  type: z.ZodLiteral<"environment">;
+  runtime: z.ZodEnum<{
+    java: "java";
+    python: "python";
+    R: "R";
+  }>;
+  "r-version": z.ZodOptional<z.ZodString>;
+  "python-version": z.ZodOptional<z.ZodString>;
+  "java-version": z.ZodOptional<z.ZodString>;
+  envVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  binDir: z.ZodString;
+}, z.core.$strip>;
+type environmentType = z.infer<typeof environmentSchema>;
+declare const binarySchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  roots: z.ZodRecord<z.ZodEnum<{
+    "linux-x64": "linux-x64";
+    "linux-aarch64": "linux-aarch64";
+    "macosx-x64": "macosx-x64";
+    "macosx-aarch64": "macosx-aarch64";
+    "windows-x64": "windows-x64";
+    "windows-aarch64": "windows-aarch64";
+  }> & z.core.$partial, z.ZodString>;
+  type: z.ZodLiteral<"binary">;
+}, z.core.$strip>;
+type binaryType = z.infer<typeof binarySchema>;
+declare const javaSchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  type: z.ZodLiteral<"java">;
+  environment: z.ZodString;
+}, z.core.$strip>;
+type javaType = z.infer<typeof javaSchema>;
+declare const pythonSchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  "docker-registry": z.ZodDefault<z.ZodString>;
+  pkg: z.ZodDefault<z.ZodString>;
+  type: z.ZodLiteral<"python">;
+  environment: z.ZodString;
+  dependencies: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    toolset: z.ZodLiteral<"pip">;
+    requirements: z.ZodString;
+  }, z.core.$strict>]>>;
+}, z.core.$strip>;
+type pythonType = z.infer<typeof pythonSchema>;
+declare const rSchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  type: z.ZodLiteral<"R">;
+  environment: z.ZodString;
+}, z.core.$strip>;
+type rType = z.infer<typeof rSchema>;
+declare const condaSchema: z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  roots: z.ZodRecord<z.ZodEnum<{
+    "linux-x64": "linux-x64";
+    "linux-aarch64": "linux-aarch64";
+    "macosx-x64": "macosx-x64";
+    "macosx-aarch64": "macosx-aarch64";
+    "windows-x64": "windows-x64";
+    "windows-aarch64": "windows-aarch64";
+  }> & z.core.$partial, z.ZodString>;
+  "docker-registry": z.ZodDefault<z.ZodString>;
+  pkg: z.ZodDefault<z.ZodString>;
+  type: z.ZodLiteral<"conda">;
+  "micromamba-version": z.ZodDefault<z.ZodString>;
+  "conda-root-dir": z.ZodDefault<z.ZodString>;
+  spec: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type condaType = z.infer<typeof condaSchema>;
+declare const dockerSchema: z.ZodObject<{
+  type: z.ZodLiteral<"docker">;
+  registry: z.ZodDefault<z.ZodString>;
+  context: z.ZodString;
+  dockerfile: z.ZodDefault<z.ZodString>;
+  pkg: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+type dockerType = z.infer<typeof dockerSchema>;
+declare const anyArtifactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  type: z.ZodLiteral<"asset">;
+}, z.core.$strict>, z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  roots: z.ZodRecord<z.ZodEnum<{
+    "linux-x64": "linux-x64";
+    "linux-aarch64": "linux-aarch64";
+    "macosx-x64": "macosx-x64";
+    "macosx-aarch64": "macosx-aarch64";
+    "windows-x64": "windows-x64";
+    "windows-aarch64": "windows-aarch64";
+  }> & z.core.$partial, z.ZodString>;
+  type: z.ZodLiteral<"environment">;
+  runtime: z.ZodEnum<{
+    java: "java";
+    python: "python";
+    R: "R";
+  }>;
+  "r-version": z.ZodOptional<z.ZodString>;
+  "python-version": z.ZodOptional<z.ZodString>;
+  "java-version": z.ZodOptional<z.ZodString>;
+  envVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  binDir: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  roots: z.ZodRecord<z.ZodEnum<{
+    "linux-x64": "linux-x64";
+    "linux-aarch64": "linux-aarch64";
+    "macosx-x64": "macosx-x64";
+    "macosx-aarch64": "macosx-aarch64";
+    "windows-x64": "windows-x64";
+    "windows-aarch64": "windows-aarch64";
+  }> & z.core.$partial, z.ZodString>;
+  type: z.ZodLiteral<"binary">;
+}, z.core.$strip>, z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  type: z.ZodLiteral<"java">;
+  environment: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  "docker-registry": z.ZodDefault<z.ZodString>;
+  pkg: z.ZodDefault<z.ZodString>;
+  type: z.ZodLiteral<"python">;
+  environment: z.ZodString;
+  dependencies: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    toolset: z.ZodLiteral<"pip">;
+    requirements: z.ZodString;
+  }, z.core.$strict>]>>;
+}, z.core.$strip>, z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  root: z.ZodString;
+  type: z.ZodLiteral<"R">;
+  environment: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  version: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  registry: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    downloadURL: z.ZodOptional<z.ZodString>;
+    storageURL: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  roots: z.ZodRecord<z.ZodEnum<{
+    "linux-x64": "linux-x64";
+    "linux-aarch64": "linux-aarch64";
+    "macosx-x64": "macosx-x64";
+    "macosx-aarch64": "macosx-aarch64";
+    "windows-x64": "windows-x64";
+    "windows-aarch64": "windows-aarch64";
+  }> & z.core.$partial, z.ZodString>;
+  "docker-registry": z.ZodDefault<z.ZodString>;
+  pkg: z.ZodDefault<z.ZodString>;
+  type: z.ZodLiteral<"conda">;
+  "micromamba-version": z.ZodDefault<z.ZodString>;
+  "conda-root-dir": z.ZodDefault<z.ZodString>;
+  spec: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"docker">;
+  registry: z.ZodDefault<z.ZodString>;
+  context: z.ZodString;
+  dockerfile: z.ZodDefault<z.ZodString>;
+  pkg: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>]>;
+type anyArtifactType = z.infer<typeof anyArtifactSchema>;
+type withType<Typ, Orig> = Orig & {
+  type: Typ;
+};
+type withId<T> = T & {
+  id: string;
+};
+//#endregion
+export { anyArtifactType, artifactType, assetType, binaryType, condaType, dockerType, environmentType, javaType, pythonType, rType, registry, withId, withType };
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/core/schemas/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","names":[],"sources":["../../../src/core/schemas/artifacts.ts"],"mappings":";;;cAKa,aAAA;AAAA,KAUD,YAAA,WAAuB,aAAA;AAAA,cA+BtB,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;KAKf,QAAA,GAAW,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,cA6EzB,WAAA,EAAW,CAAA,CAAA,SAAA;;;;;;;;;;;KAIZ,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,WAAA;AAAA,cAE1B,iBAAA,EAAiB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA6BlB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,cAEhC,YAAA,EAAY,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;KAGb,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,YAAA;AAAA,cAE3B,UAAA,EAAU,CAAA,CAAA,SAAA;;;;;;;;;;;;KAIX,QAAA,GAAW,CAAA,CAAE,KAAA,QAAa,UAAA;AAAA,cASzB,YAAA,EAAY,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;KASb,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,YAAA;AAAA,cAE3B,OAAA,EAAO,CAAA,CAAA,SAAA;;;;;;;;;;;;KAIR,KAAA,GAAQ,CAAA,CAAE,KAAA,QAAa,OAAA;AAAA,cAEtB,WAAA,EAAW,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;KAoBZ,SAAA,GAAY,CAAA,CAAE,KAAA,QAAa,WAAA;AAAA,cAE1B,YAAA,EAAY,CAAA,CAAA,SAAA;;;;;;;KAqCb,UAAA,GAAa,CAAA,CAAE,KAAA,QAAa,YAAA;AAAA,cAE3B,iBAAA,EAAiB,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWlB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAKjC,QAAA,cAAsB,IAAA;EAAS,IAAA,EAAM,GAAA;AAAA;AAAA,KACrC,MAAA,MAAY,CAAA;EAAM,EAAA;AAAA"}

package/dist/core/schemas/artifacts.js

@@ -0,0 +1,122 @@
+import { BIN_REGISTRY_DOWNLOAD_URL, BIN_REGISTRY_NAME, CONDA_DATA_LOCATION, CONDA_MICROMAMBA_VERSION, CONDA_SOURCE_ENV_SPEC_FILE, DOCKER_DOCKERFILE, DOCKER_PLACEHOLDER_PKG, DOCKER_REGISTRY } from "../../defaults.js";
+import { AllPlatforms } from "../util.js";
+import { z } from "zod/v4";
+//#region src/core/schemas/artifacts.ts
+const artifactTypes = [
+	"asset",
+	"environment",
+	"binary",
+	"java",
+	"python",
+	"R",
+	"docker",
+	"conda"
+];
+const archiveArtifactTypes = [
+	"asset",
+	"environment",
+	"binary",
+	"java",
+	"python",
+	"R",
+	"conda"
+];
+const crossplatformTypes = [
+	"asset",
+	"java",
+	"python",
+	"R"
+];
+const dockerAutogenTypes = ["python", "conda"];
+function isBuildable(aType) {
+	return artifactTypes.includes(aType);
+}
+function isCrossPlatform(aType) {
+	return crossplatformTypes.includes(aType);
+}
+const runEnvironmentTypes = [
+	"java",
+	"python",
+	"R"
+];
+const registrySchema = z.strictObject({
+	name: z.string(),
+	downloadURL: z.string().optional(),
+	storageURL: z.string().optional()
+});
+const registryOrRef = z.union([z.string(), registrySchema]);
+const archiveRulesSchema = z.object({
+	registry: registryOrRef.default({
+		name: BIN_REGISTRY_NAME,
+		downloadURL: BIN_REGISTRY_DOWNLOAD_URL
+	}),
+	name: z.string().optional(),
+	version: z.string().optional(),
+	root: z.string("package archive content directory is required"),
+	roots: z.partialRecord(z.enum(AllPlatforms), z.string("path to package archive content directory cannot be empty").min(1), { error: (iss) => {
+		if (iss.input === void 0) return "list of supported platforms is required: { <platform>: <dir> }\nsupported platforms:\n  " + AllPlatforms.join("\n  ");
+		return null;
+	} }).refine((val) => Object.keys(val).length > 0, { message: "specify at least one platform supported by this software in format: { <platform>: <dir> }\nsupported platforms:\n  " + AllPlatforms.join("\n  ") }).describe("please, provide settings only for supported platforms: " + AllPlatforms.join(", "))
+});
+const dockerRulesSchema = z.object({
+	["docker-registry"]: z.string("python software is also automatically shipped as docker image. Docker registry cannot be empty").min(1).default(DOCKER_REGISTRY).describe("registry to use for pushing autogenerated docker image"),
+	pkg: z.string().default(DOCKER_PLACEHOLDER_PKG).describe("{pkg} placeholder value to be used in \"cmd\" and arguments (for docker autogeneration)")
+});
+const artifactIDSchema = z.string().regex(/:/, { message: "tengo artifact ID must have <npmPackage>:<artifactName> format, e.g @milaboratory/runenv-java-corretto:21.2.0.4.1" }).describe("ID of tengo build artifact");
+const assetSchema = archiveRulesSchema.omit({ roots: true }).extend({ type: z.literal("asset") }).strict();
+const environmentSchema = archiveRulesSchema.omit({ root: true }).extend({
+	type: z.literal("environment"),
+	runtime: z.enum(runEnvironmentTypes).describe("type of runtime this run environment provides: 'java', 'python' and so on"),
+	["r-version"]: z.string().optional(),
+	["python-version"]: z.string().optional(),
+	["java-version"]: z.string().optional(),
+	envVars: z.array(z.string().regex(/=/, "environment variable should be specified in format: <var-name>=<var-value>, i.e.: MY_ENV=value")).optional(),
+	binDir: z.string().describe("path to 'bin' directory to be added to PATH when software uses this run environment")
+});
+const binarySchema = archiveRulesSchema.omit({ root: true }).extend({ type: z.literal("binary") });
+const javaSchema = archiveRulesSchema.omit({ roots: true }).extend({
+	type: z.literal("java"),
+	environment: artifactIDSchema
+});
+const pipToolsetSchema = z.strictObject({
+	toolset: z.literal("pip"),
+	requirements: z.string().describe("path to requrements.txt inside package archive")
+});
+const pythonToolsetSchema = z.discriminatedUnion("toolset", [pipToolsetSchema]);
+const pythonSchema = archiveRulesSchema.omit({ roots: true }).extend(dockerRulesSchema.shape).extend({
+	type: z.literal("python"),
+	environment: artifactIDSchema,
+	dependencies: pythonToolsetSchema.optional()
+});
+const rSchema = archiveRulesSchema.omit({ roots: true }).extend({
+	type: z.literal("R"),
+	environment: artifactIDSchema
+});
+const condaSchema = archiveRulesSchema.omit({ root: true }).extend(dockerRulesSchema.shape).extend({
+	type: z.literal("conda"),
+	["micromamba-version"]: z.string().default(CONDA_MICROMAMBA_VERSION).describe("version of micromamba to be used to operate with conda environments"),
+	["conda-root-dir"]: z.string().default(CONDA_DATA_LOCATION).describe("root directory of conda environment inside package root"),
+	spec: z.string().default(CONDA_SOURCE_ENV_SPEC_FILE).describe(`path to conda environment yaml specification relative to package.json`)
+});
+const dockerSchema = z.object({
+	type: z.literal("docker"),
+	registry: z.string().default(DOCKER_REGISTRY).describe("registry+repository URL to use for pulling this image"),
+	context: z.string().refine((val) => val !== "./" && val !== ".", { message: "Context cannot be \"./\" or \".\" - use absolute path or relative path without \"./\" prefix" }).describe("relative path to context directory from folder where command is executed or absolute path to context folder (cannot be \"./\" or \".\")"),
+	dockerfile: z.string().default(DOCKER_DOCKERFILE).describe("relative path to 'Dockerfile' file from folder where command is executed or absolute path to the file"),
+	pkg: z.string().default(DOCKER_PLACEHOLDER_PKG).describe("{pkg} placeholder value to be used in \"cmd\" and arguments")
+});
+const anyArtifactSchema = z.discriminatedUnion("type", [
+	assetSchema,
+	environmentSchema,
+	binarySchema,
+	javaSchema,
+	pythonSchema,
+	rSchema,
+	condaSchema,
+	dockerSchema
+]);
+const artifactIndexSchema = z.record(z.string(), anyArtifactSchema);
+//#endregion
+export { archiveArtifactTypes, artifactIndexSchema, assetSchema, binarySchema, condaSchema, dockerAutogenTypes, dockerSchema, environmentSchema, isBuildable, isCrossPlatform, javaSchema, pythonSchema, rSchema, runEnvironmentTypes };
+
+//# sourceMappingURL=artifacts.js.map

package/dist/core/schemas/artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.js","names":["defaults.BIN_REGISTRY_NAME","defaults.BIN_REGISTRY_DOWNLOAD_URL","util.AllPlatforms","defaults.DOCKER_REGISTRY","defaults.DOCKER_PLACEHOLDER_PKG","defaults.CONDA_MICROMAMBA_VERSION","defaults.CONDA_DATA_LOCATION","defaults.CONDA_SOURCE_ENV_SPEC_FILE","defaults.DOCKER_DOCKERFILE"],"sources":["../../../src/core/schemas/artifacts.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport * as defaults from \"../../defaults\";\nimport * as util from \"../util\";\n\n// All known artifact types\nexport const artifactTypes = [\n  \"asset\",\n  \"environment\",\n  \"binary\",\n  \"java\",\n  \"python\",\n  \"R\",\n  \"docker\",\n  \"conda\",\n] as const;\nexport type artifactType = (typeof artifactTypes)[number];\n\n// TODO: change these to type definitions, not arrays. This will simplify type narrowing logic throughout the code.\nexport const archiveArtifactTypes: artifactType[] = [\n  \"asset\",\n  \"environment\",\n  \"binary\",\n  \"java\",\n  \"python\",\n  \"R\",\n  \"conda\",\n] as const;\nexport const crossplatformTypes: artifactType[] = [\"asset\", \"java\", \"python\", \"R\"] as const;\nexport const dockerAutogenTypes: artifactType[] = [\"python\", \"conda\"] as const;\nexport const dockerArchitectures: util.ArchType[] = [\"x64\"] as const;\n\nexport function isBuildable(aType: artifactType): boolean {\n  // All known artifact types are buildable. No exceptions so far.\n  return artifactTypes.includes(aType);\n}\n\nexport function isCrossPlatform(aType: artifactType): boolean {\n  return crossplatformTypes.includes(aType);\n}\n\nexport const runEnvironmentTypes = [\"java\", \"python\", \"R\"] as const;\nexport type runEnvironmentType = (typeof runEnvironmentTypes)[number];\n\nexport const pythonToolsets = [\"pip\"] as const;\nexport type pythonToolsetName = (typeof pythonToolsets)[number];\n\nexport const registrySchema = z.strictObject({\n  name: z.string(),\n  downloadURL: z.string().optional(),\n  storageURL: z.string().optional(),\n});\nexport type registry = z.infer<typeof registrySchema>;\n\nexport const registryOrRef = z.union([z.string(), registrySchema]);\n\n// common fields for all buildable artifacts\n// TODO: create new type for binary packages\nconst archiveRulesSchema = z.object({\n  registry: registryOrRef.default({\n    name: defaults.BIN_REGISTRY_NAME,\n    downloadURL: defaults.BIN_REGISTRY_DOWNLOAD_URL,\n  }),\n\n  name: z.string().optional(),\n  version: z.string().optional(),\n\n  root: z.string(\"package archive content directory is required\"),\n  roots: z\n    .partialRecord(\n      z.enum(\n        util.AllPlatforms as [\n          (typeof util.AllPlatforms)[number],\n          ...(typeof util.AllPlatforms)[number][],\n        ],\n      ),\n      z.string(\"path to package archive content directory cannot be empty\").min(1),\n      {\n        error: (iss) => {\n          if (iss.input === undefined) {\n            return (\n              \"list of supported platforms is required: { <platform>: <dir> }\\n\" +\n              \"supported platforms:\\n  \" +\n              util.AllPlatforms.join(\"\\n  \")\n            );\n          }\n          return null;\n        },\n      },\n    )\n    .refine((val) => Object.keys(val).length > 0, {\n      message:\n        \"specify at least one platform supported by this software in format: { <platform>: <dir> }\\n\" +\n        \"supported platforms:\\n  \" +\n        util.AllPlatforms.join(\"\\n  \"),\n    })\n    .describe(\n      \"please, provide settings only for supported platforms: \" + util.AllPlatforms.join(\", \"),\n    ),\n});\nexport type archiveRules = z.infer<typeof archiveRulesSchema>;\n\nconst dockerRulesSchema = z.object({\n  [\"docker-registry\"]: z\n    .string(\n      \"python software is also automatically shipped as docker image. Docker registry cannot be empty\",\n    )\n    .min(1)\n    .default(defaults.DOCKER_REGISTRY)\n    .describe(\"registry to use for pushing autogenerated docker image\"),\n\n  pkg: z\n    .string()\n    .default(defaults.DOCKER_PLACEHOLDER_PKG)\n    .describe(\n      '{pkg} placeholder value to be used in \"cmd\" and arguments (for docker autogeneration)',\n    ),\n});\n\nexport const artifactIDSchema = z\n  .string()\n  .regex(/:/, {\n    message:\n      \"tengo artifact ID must have <npmPackage>:<artifactName> format, e.g @milaboratory/runenv-java-corretto:21.2.0.4.1\",\n  })\n  .describe(\"ID of tengo build artifact\");\n\nexport type artifactIDString = z.infer<typeof artifactIDSchema>;\n\nexport const assetSchema = archiveRulesSchema\n  .omit({ roots: true })\n  .extend({ type: z.literal(\"asset\") })\n  .strict();\nexport type assetType = z.infer<typeof assetSchema>;\n\nexport const environmentSchema = archiveRulesSchema.omit({ root: true }).extend({\n  type: z.literal(\"environment\"),\n\n  runtime: z\n    .enum(runEnvironmentTypes)\n    .describe(\"type of runtime this run environment provides: 'java', 'python' and so on\"),\n\n  [\"r-version\"]: z.string().optional(),\n  [\"python-version\"]: z.string().optional(),\n  [\"java-version\"]: z.string().optional(),\n\n  envVars: z\n    .array(\n      z\n        .string()\n        .regex(\n          /=/,\n          \"environment variable should be specified in format: <var-name>=<var-value>, i.e.: MY_ENV=value\",\n        ),\n    )\n    .optional(),\n\n  binDir: z\n    .string()\n    .describe(\n      \"path to 'bin' directory to be added to PATH when software uses this run environment\",\n    ),\n});\n\nexport type environmentType = z.infer<typeof environmentSchema>;\n\nexport const binarySchema = archiveRulesSchema.omit({ root: true }).extend({\n  type: z.literal(\"binary\"),\n});\nexport type binaryType = z.infer<typeof binarySchema>;\n\nexport const javaSchema = archiveRulesSchema.omit({ roots: true }).extend({\n  type: z.literal(\"java\"),\n  environment: artifactIDSchema,\n});\nexport type javaType = z.infer<typeof javaSchema>;\n\nconst pipToolsetSchema = z.strictObject({\n  toolset: z.literal(\"pip\"),\n  requirements: z.string().describe(\"path to requrements.txt inside package archive\"),\n});\n\nexport const pythonToolsetSchema = z.discriminatedUnion(\"toolset\", [pipToolsetSchema]);\n\nexport const pythonSchema = archiveRulesSchema\n  .omit({ roots: true })\n  .extend(dockerRulesSchema.shape)\n  .extend({\n    type: z.literal(\"python\"),\n\n    environment: artifactIDSchema,\n    dependencies: pythonToolsetSchema.optional(),\n  });\nexport type pythonType = z.infer<typeof pythonSchema>;\n\nexport const rSchema = archiveRulesSchema.omit({ roots: true }).extend({\n  type: z.literal(\"R\"),\n  environment: artifactIDSchema,\n});\nexport type rType = z.infer<typeof rSchema>;\n\nexport const condaSchema = archiveRulesSchema\n  .omit({ root: true })\n  .extend(dockerRulesSchema.shape)\n  .extend({\n    type: z.literal(\"conda\"),\n\n    [\"micromamba-version\"]: z\n      .string()\n      .default(defaults.CONDA_MICROMAMBA_VERSION)\n      .describe(\"version of micromamba to be used to operate with conda environments\"),\n    [\"conda-root-dir\"]: z\n      .string()\n      .default(defaults.CONDA_DATA_LOCATION)\n      .describe(\"root directory of conda environment inside package root\"),\n\n    spec: z\n      .string()\n      .default(defaults.CONDA_SOURCE_ENV_SPEC_FILE)\n      .describe(`path to conda environment yaml specification relative to package.json`),\n  });\nexport type condaType = z.infer<typeof condaSchema>;\n\nexport const dockerSchema = z.object({\n  type: z.literal(\"docker\"),\n\n  registry: z\n    .string()\n    .default(defaults.DOCKER_REGISTRY)\n    .describe(\"registry+repository URL to use for pulling this image\"),\n\n  // build from custom Dockerfile\n  context: z\n    .string()\n    .refine((val) => val !== \"./\" && val !== \".\", {\n      message:\n        'Context cannot be \"./\" or \".\" - use absolute path or relative path without \"./\" prefix',\n    })\n    .describe(\n      'relative path to context directory from folder where command is executed or absolute path to context folder (cannot be \"./\" or \".\")',\n    ),\n\n  dockerfile: z\n    .string()\n    .default(defaults.DOCKER_DOCKERFILE)\n    .describe(\n      \"relative path to 'Dockerfile' file from folder where command is executed or absolute path to the file\",\n    ),\n\n  pkg: z\n    .string()\n    .default(defaults.DOCKER_PLACEHOLDER_PKG)\n    .describe('{pkg} placeholder value to be used in \"cmd\" and arguments'),\n\n  // import existing image\n  // entrypoint: z\n  //   .array(z.string())\n  //   .optional()\n  //   .describe('replace image\\'s ENTRYPOINT with this value when running container'),\n});\nexport type dockerType = z.infer<typeof dockerSchema>;\n\nexport const anyArtifactSchema = z.discriminatedUnion(\"type\", [\n  assetSchema,\n  environmentSchema,\n  binarySchema,\n  javaSchema,\n  pythonSchema,\n  rSchema,\n  condaSchema,\n  dockerSchema,\n]);\n\nexport type anyArtifactType = z.infer<typeof anyArtifactSchema>;\n\nexport const artifactIndexSchema = z.record(z.string(), anyArtifactSchema);\nexport type artifactIndexType = z.infer<typeof artifactIndexSchema>;\n\nexport type withType<Typ, Orig> = Orig & { type: Typ };\nexport type withId<T> = T & { id: string };\n"],"mappings":"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"}

package/dist/core/schemas/entrypoints.cjs

@@ -0,0 +1,43 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_util = require("../util.cjs");
+const require_artifacts = require("./artifacts.cjs");
+let zod_v4 = require("zod/v4");
+//#region src/core/schemas/entrypoints.ts
+const envVarsSchema = zod_v4.z.array(zod_v4.z.string().regex(/=/, "full environment variable specification is required: <var-name>=<var-value>, e.g.: IS_CI=yes"));
+const EnyrypointReferencePattern = /^(?<fullName>(?:(?<scope>@[a-z0-9-.]+)\/)?(?<name>[a-z0-9-.]+))\/(?<path>.*)$/;
+const referenceSchema = zod_v4.z.string().regex(EnyrypointReferencePattern, "entrypoint reference must contain full package name and path to the file inside");
+const orRef = (schema) => zod_v4.z.union([zod_v4.z.string("not a reference to artifact").describe("reference to artifact in \"artifacts\" section"), schema]);
+const softwareOptionsSchema = zod_v4.z.strictObject({
+	cmd: zod_v4.z.array(zod_v4.z.string("command artument must be a string")).min(1, { error: "at least one argument is required" }).refine((cmd) => cmd[0].trim() != "", { error: "first cmd argument must be non-empty string" }).describe("command to run for this entrypoint. This command will be appended by <args> set inside workflow"),
+	envVars: envVarsSchema.optional().describe("list of environment variables to be set for this entrypoint")
+});
+const environmentOptionsSchema = zod_v4.z.strictObject({
+	artifact: orRef(require_artifacts.environmentSchema.omit({ type: true })),
+	envVars: envVarsSchema.optional().describe("list of environment variables to be set for any command inside this run environment")
+});
+const entrypointSchema = zod_v4.z.strictObject({
+	reference: referenceSchema.optional(),
+	asset: orRef(require_artifacts.assetSchema.omit({ type: true })).optional(),
+	environment: environmentOptionsSchema.optional(),
+	binary: zod_v4.z.union([
+		softwareOptionsSchema.extend({ artifact: orRef(require_artifacts.binarySchema) }),
+		softwareOptionsSchema.extend({ artifact: orRef(require_artifacts.javaSchema) }),
+		softwareOptionsSchema.extend({ artifact: orRef(require_artifacts.pythonSchema) }),
+		softwareOptionsSchema.extend({ artifact: orRef(require_artifacts.rSchema) })
+	]).optional(),
+	conda: softwareOptionsSchema.extend({ artifact: orRef(require_artifacts.condaSchema.omit({ type: true })) }).optional(),
+	docker: softwareOptionsSchema.extend({ artifact: orRef(require_artifacts.dockerSchema.omit({ type: true })) }).optional()
+}).refine((data) => {
+	const n = require_util.toInt(data.reference) + require_util.toInt(data.asset && !data.docker) + require_util.toInt(data.binary || data.binary && data.docker) + require_util.toInt(data.conda || data.conda && data.docker) + require_util.toInt(data.environment && !data.docker);
+	if (n === 0) return Boolean(data.docker);
+	return n === 1;
+}, {
+	message: "entrypoint cannot point to several packages at once: choose 'reference', 'asset', 'binary', 'environment' or 'docker'",
+	path: ["reference | asset | binary | environment | docker"]
+});
+const entrypointListSchema = zod_v4.z.record(zod_v4.z.string().regex(/[-_a-z0-9.]/).describe("name of entrypoint descriptor, client should import to use this entrypoint (assets.importSoftware)"), entrypointSchema);
+//#endregion
+exports.EnyrypointReferencePattern = EnyrypointReferencePattern;
+exports.entrypointListSchema = entrypointListSchema;
+
+//# sourceMappingURL=entrypoints.cjs.map

package/dist/core/schemas/entrypoints.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoints.cjs","names":["z"],"sources":["../../../src/core/schemas/entrypoints.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport * as artifacts from \"./artifacts\";\nimport * as util from \"../util\";\n\nconst envVarsSchema = z.array(\n  z\n    .string()\n    .regex(\n      /=/,\n      \"full environment variable specification is required: <var-name>=<var-value>, e.g.: IS_CI=yes\",\n    ),\n);\n\nexport const EnyrypointReferencePattern =\n  /^(?<fullName>(?:(?<scope>@[a-z0-9-.]+)\\/)?(?<name>[a-z0-9-.]+))\\/(?<path>.*)$/;\n\nexport const referenceSchema = z\n  .string()\n  .regex(\n    EnyrypointReferencePattern,\n    \"entrypoint reference must contain full package name and path to the file inside\",\n  );\n\nconst orRef = <T extends z.ZodTypeAny>(schema: T) =>\n  z.union([\n    z\n      .string(\"not a reference to artifact\")\n      .describe('reference to artifact in \"artifacts\" section'),\n    schema,\n  ]);\n\n// Common options for all software packages: everything that can be run on backend side.\nexport const softwareOptionsSchema = z.strictObject({\n  cmd: z\n    .array(z.string(\"command artument must be a string\"))\n    .min(1, { error: \"at least one argument is required\" })\n    .refine((cmd) => cmd[0].trim() != \"\", { error: \"first cmd argument must be non-empty string\" })\n    .describe(\n      \"command to run for this entrypoint. This command will be appended by <args> set inside workflow\",\n    ),\n  envVars: envVarsSchema\n    .optional()\n    .describe(\"list of environment variables to be set for this entrypoint\"),\n});\nexport type softwareOptionsType = z.infer<typeof softwareOptionsSchema>;\n\nexport const environmentOptionsSchema = z.strictObject({\n  artifact: orRef(artifacts.environmentSchema.omit({ type: true })),\n  envVars: envVarsSchema\n    .optional()\n    .describe(\n      \"list of environment variables to be set for any command inside this run environment\",\n    ),\n});\n\n// Full schema of single entrypoint in block-software.entrypoints\nexport const entrypointSchema = z\n  .strictObject({\n    reference: referenceSchema.optional(),\n    asset: orRef(artifacts.assetSchema.omit({ type: true })).optional(),\n    environment: environmentOptionsSchema.optional(),\n\n    binary: z\n      .union([\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.binarySchema) }),\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.javaSchema) }),\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.pythonSchema) }),\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.rSchema) }),\n      ])\n      .optional(), // TODO: reduce nesting: put java, python and r to the level of binary, like conda.\n\n    conda: softwareOptionsSchema\n      .extend({ artifact: orRef(artifacts.condaSchema.omit({ type: true })) })\n      .optional(),\n    docker: softwareOptionsSchema\n      .extend({ artifact: orRef(artifacts.dockerSchema.omit({ type: true })) })\n      .optional(),\n  })\n  .refine(\n    (data) => {\n      const n =\n        util.toInt(data.reference) +\n        util.toInt(data.asset && !data.docker) + // no docker for assets\n        util.toInt(data.binary || (data.binary && data.docker)) + // allow both docker and binary to be set in single entrypoint\n        util.toInt(data.conda || (data.conda && data.docker)) + // allow both docker and conda to be set in single entrypoint\n        util.toInt(data.environment && !data.docker); // no docker for environments\n\n      if (n === 0) {\n        return Boolean(data.docker); // allow separate docker entrypoints (without binary/conda/...)\n      }\n\n      return n === 1;\n    },\n    {\n      message:\n        \"entrypoint cannot point to several packages at once: choose 'reference', 'asset', 'binary', 'environment' or 'docker'\",\n      path: [\"reference | asset | binary | environment | docker\"],\n    },\n  );\nexport type entrypointType = z.infer<typeof entrypointSchema>;\n\n// Full block-software.entrypoints list schema\nexport const entrypointListSchema = z.record(\n  z\n    .string()\n    .regex(/[-_a-z0-9.]/)\n    .describe(\n      \"name of entrypoint descriptor, client should import to use this entrypoint (assets.importSoftware)\",\n    ),\n  entrypointSchema,\n);\nexport type entrypointListType = z.infer<typeof entrypointListSchema>;\n\nexport interface ReferenceEntrypoint {\n  type: \"reference\";\n  name: string;\n  reference: string;\n}\n\nexport interface AssetEntrypoint {\n  type: \"asset\";\n  name: string;\n  artifact: artifacts.withId<artifacts.assetType>;\n}\n\nexport interface SoftwareEntrypoint {\n  type: \"software\";\n  name: string;\n  artifact: artifacts.withId<\n    | artifacts.binaryType\n    | artifacts.condaType\n    | artifacts.javaType\n    | artifacts.pythonType\n    | artifacts.rType\n    | artifacts.dockerType\n  >;\n  cmd: string[];\n  env: string[];\n}\n\nexport interface EnvironmentEntrypoint {\n  type: \"environment\";\n  name: string;\n  artifact: artifacts.withId<artifacts.environmentType>;\n  env: string[];\n}\n\nexport type PackageEntrypoint = AssetEntrypoint | SoftwareEntrypoint | EnvironmentEntrypoint;\nexport type Entrypoint = ReferenceEntrypoint | PackageEntrypoint;\nexport type EntrypointType = Extract<Entrypoint, { type: string }>[\"type\"];\n"],"mappings":";;;;;AAIA,MAAM,gBAAgBA,OAAAA,EAAE,MACtBA,OAAAA,EACG,QAAQ,CACR,MACC,KACA,+FACD,CACJ;AAED,MAAa,6BACX;AAEF,MAAa,kBAAkBA,OAAAA,EAC5B,QAAQ,CACR,MACC,4BACA,kFACD;AAEH,MAAM,SAAiC,WACrCA,OAAAA,EAAE,MAAM,CACNA,OAAAA,EACG,OAAO,8BAA8B,CACrC,SAAS,iDAA+C,EAC3D,OACD,CAAC;AAGJ,MAAa,wBAAwBA,OAAAA,EAAE,aAAa;CAClD,KAAKA,OAAAA,EACF,MAAMA,OAAAA,EAAE,OAAO,oCAAoC,CAAC,CACpD,IAAI,GAAG,EAAE,OAAO,qCAAqC,CAAC,CACtD,QAAQ,QAAQ,IAAI,GAAG,MAAM,IAAI,IAAI,EAAE,OAAO,+CAA+C,CAAC,CAC9F,SACC,kGACD;CACH,SAAS,cACN,UAAU,CACV,SAAS,8DAA8D;CAC3E,CAAC;AAGF,MAAa,2BAA2BA,OAAAA,EAAE,aAAa;CACrD,UAAU,MAAA,kBAAA,kBAAkC,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC;CACjE,SAAS,cACN,UAAU,CACV,SACC,sFACD;CACJ,CAAC;AAGF,MAAa,mBAAmBA,OAAAA,EAC7B,aAAa;CACZ,WAAW,gBAAgB,UAAU;CACrC,OAAO,MAAA,kBAAA,YAA4B,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC,UAAU;CACnE,aAAa,yBAAyB,UAAU;CAEhD,QAAQA,OAAAA,EACL,MAAM;EACL,sBAAsB,OAAO,EAAE,UAAU,MAAA,kBAAA,aAA6B,EAAE,CAAC;EACzE,sBAAsB,OAAO,EAAE,UAAU,MAAA,kBAAA,WAA2B,EAAE,CAAC;EACvE,sBAAsB,OAAO,EAAE,UAAU,MAAA,kBAAA,aAA6B,EAAE,CAAC;EACzE,sBAAsB,OAAO,EAAE,UAAU,MAAA,kBAAA,QAAwB,EAAE,CAAC;EACrE,CAAC,CACD,UAAU;CAEb,OAAO,sBACJ,OAAO,EAAE,UAAU,MAAA,kBAAA,YAA4B,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CACvE,UAAU;CACb,QAAQ,sBACL,OAAO,EAAE,UAAU,MAAA,kBAAA,aAA6B,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CACxE,UAAU;CACd,CAAC,CACD,QACE,SAAS;CACR,MAAM,IAAA,aAAA,MACO,KAAK,UAAU,GAAA,aAAA,MACf,KAAK,SAAS,CAAC,KAAK,OAAO,GAAA,aAAA,MAC3B,KAAK,UAAW,KAAK,UAAU,KAAK,OAAQ,GAAA,aAAA,MAC5C,KAAK,SAAU,KAAK,SAAS,KAAK,OAAQ,GAAA,aAAA,MAC1C,KAAK,eAAe,CAAC,KAAK,OAAO;AAE9C,KAAI,MAAM,EACR,QAAO,QAAQ,KAAK,OAAO;AAG7B,QAAO,MAAM;GAEf;CACE,SACE;CACF,MAAM,CAAC,oDAAoD;CAC5D,CACF;AAIH,MAAa,uBAAuBA,OAAAA,EAAE,OACpCA,OAAAA,EACG,QAAQ,CACR,MAAM,cAAc,CACpB,SACC,qGACD,EACH,iBACD"}

package/dist/core/schemas/entrypoints.d.ts

@@ -0,0 +1,32 @@
+import { assetType, binaryType, condaType, dockerType, environmentType, javaType, pythonType, rType, withId } from "./artifacts.js";
+import { z } from "zod/v4";
+
+//#region src/core/schemas/entrypoints.d.ts
+interface ReferenceEntrypoint {
+  type: "reference";
+  name: string;
+  reference: string;
+}
+interface AssetEntrypoint {
+  type: "asset";
+  name: string;
+  artifact: withId<assetType>;
+}
+interface SoftwareEntrypoint {
+  type: "software";
+  name: string;
+  artifact: withId<binaryType | condaType | javaType | pythonType | rType | dockerType>;
+  cmd: string[];
+  env: string[];
+}
+interface EnvironmentEntrypoint {
+  type: "environment";
+  name: string;
+  artifact: withId<environmentType>;
+  env: string[];
+}
+type PackageEntrypoint = AssetEntrypoint | SoftwareEntrypoint | EnvironmentEntrypoint;
+type Entrypoint = ReferenceEntrypoint | PackageEntrypoint;
+//#endregion
+export { Entrypoint, ReferenceEntrypoint };
+//# sourceMappingURL=entrypoints.d.ts.map

package/dist/core/schemas/entrypoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoints.d.ts","names":[],"sources":["../../../src/core/schemas/entrypoints.ts"],"mappings":";;;;UAiHiB,mBAAA;EACf,IAAA;EACA,IAAA;EACA,SAAA;AAAA;AAAA,UAGe,eAAA;EACf,IAAA;EACA,IAAA;EACA,QAAA,EAAU,MAAA,CAAiB,SAAA;AAAA;AAAA,UAGZ,kBAAA;EACf,IAAA;EACA,IAAA;EACA,QAAA,EAAU,MAAA,CACN,UAAA,GACA,SAAA,GACA,QAAA,GACA,UAAA,GACA,KAAA,GACA,UAAA;EAEJ,GAAA;EACA,GAAA;AAAA;AAAA,UAGe,qBAAA;EACf,IAAA;EACA,IAAA;EACA,QAAA,EAAU,MAAA,CAAiB,eAAA;EAC3B,GAAA;AAAA;AAAA,KAGU,iBAAA,GAAoB,eAAA,GAAkB,kBAAA,GAAqB,qBAAA;AAAA,KAC3D,UAAA,GAAa,mBAAA,GAAsB,iBAAA"}

package/dist/core/schemas/entrypoints.js

@@ -0,0 +1,41 @@
+import { toInt } from "../util.js";
+import { assetSchema, binarySchema, condaSchema, dockerSchema, environmentSchema, javaSchema, pythonSchema, rSchema } from "./artifacts.js";
+import { z } from "zod/v4";
+//#region src/core/schemas/entrypoints.ts
+const envVarsSchema = z.array(z.string().regex(/=/, "full environment variable specification is required: <var-name>=<var-value>, e.g.: IS_CI=yes"));
+const EnyrypointReferencePattern = /^(?<fullName>(?:(?<scope>@[a-z0-9-.]+)\/)?(?<name>[a-z0-9-.]+))\/(?<path>.*)$/;
+const referenceSchema = z.string().regex(EnyrypointReferencePattern, "entrypoint reference must contain full package name and path to the file inside");
+const orRef = (schema) => z.union([z.string("not a reference to artifact").describe("reference to artifact in \"artifacts\" section"), schema]);
+const softwareOptionsSchema = z.strictObject({
+	cmd: z.array(z.string("command artument must be a string")).min(1, { error: "at least one argument is required" }).refine((cmd) => cmd[0].trim() != "", { error: "first cmd argument must be non-empty string" }).describe("command to run for this entrypoint. This command will be appended by <args> set inside workflow"),
+	envVars: envVarsSchema.optional().describe("list of environment variables to be set for this entrypoint")
+});
+const environmentOptionsSchema = z.strictObject({
+	artifact: orRef(environmentSchema.omit({ type: true })),
+	envVars: envVarsSchema.optional().describe("list of environment variables to be set for any command inside this run environment")
+});
+const entrypointSchema = z.strictObject({
+	reference: referenceSchema.optional(),
+	asset: orRef(assetSchema.omit({ type: true })).optional(),
+	environment: environmentOptionsSchema.optional(),
+	binary: z.union([
+		softwareOptionsSchema.extend({ artifact: orRef(binarySchema) }),
+		softwareOptionsSchema.extend({ artifact: orRef(javaSchema) }),
+		softwareOptionsSchema.extend({ artifact: orRef(pythonSchema) }),
+		softwareOptionsSchema.extend({ artifact: orRef(rSchema) })
+	]).optional(),
+	conda: softwareOptionsSchema.extend({ artifact: orRef(condaSchema.omit({ type: true })) }).optional(),
+	docker: softwareOptionsSchema.extend({ artifact: orRef(dockerSchema.omit({ type: true })) }).optional()
+}).refine((data) => {
+	const n = toInt(data.reference) + toInt(data.asset && !data.docker) + toInt(data.binary || data.binary && data.docker) + toInt(data.conda || data.conda && data.docker) + toInt(data.environment && !data.docker);
+	if (n === 0) return Boolean(data.docker);
+	return n === 1;
+}, {
+	message: "entrypoint cannot point to several packages at once: choose 'reference', 'asset', 'binary', 'environment' or 'docker'",
+	path: ["reference | asset | binary | environment | docker"]
+});
+const entrypointListSchema = z.record(z.string().regex(/[-_a-z0-9.]/).describe("name of entrypoint descriptor, client should import to use this entrypoint (assets.importSoftware)"), entrypointSchema);
+//#endregion
+export { EnyrypointReferencePattern, entrypointListSchema };
+
+//# sourceMappingURL=entrypoints.js.map

package/dist/core/schemas/entrypoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoints.js","names":["artifacts.binarySchema","artifacts.javaSchema","artifacts.pythonSchema","artifacts.rSchema","util.toInt"],"sources":["../../../src/core/schemas/entrypoints.ts"],"sourcesContent":["import { z } from \"zod/v4\";\nimport * as artifacts from \"./artifacts\";\nimport * as util from \"../util\";\n\nconst envVarsSchema = z.array(\n  z\n    .string()\n    .regex(\n      /=/,\n      \"full environment variable specification is required: <var-name>=<var-value>, e.g.: IS_CI=yes\",\n    ),\n);\n\nexport const EnyrypointReferencePattern =\n  /^(?<fullName>(?:(?<scope>@[a-z0-9-.]+)\\/)?(?<name>[a-z0-9-.]+))\\/(?<path>.*)$/;\n\nexport const referenceSchema = z\n  .string()\n  .regex(\n    EnyrypointReferencePattern,\n    \"entrypoint reference must contain full package name and path to the file inside\",\n  );\n\nconst orRef = <T extends z.ZodTypeAny>(schema: T) =>\n  z.union([\n    z\n      .string(\"not a reference to artifact\")\n      .describe('reference to artifact in \"artifacts\" section'),\n    schema,\n  ]);\n\n// Common options for all software packages: everything that can be run on backend side.\nexport const softwareOptionsSchema = z.strictObject({\n  cmd: z\n    .array(z.string(\"command artument must be a string\"))\n    .min(1, { error: \"at least one argument is required\" })\n    .refine((cmd) => cmd[0].trim() != \"\", { error: \"first cmd argument must be non-empty string\" })\n    .describe(\n      \"command to run for this entrypoint. This command will be appended by <args> set inside workflow\",\n    ),\n  envVars: envVarsSchema\n    .optional()\n    .describe(\"list of environment variables to be set for this entrypoint\"),\n});\nexport type softwareOptionsType = z.infer<typeof softwareOptionsSchema>;\n\nexport const environmentOptionsSchema = z.strictObject({\n  artifact: orRef(artifacts.environmentSchema.omit({ type: true })),\n  envVars: envVarsSchema\n    .optional()\n    .describe(\n      \"list of environment variables to be set for any command inside this run environment\",\n    ),\n});\n\n// Full schema of single entrypoint in block-software.entrypoints\nexport const entrypointSchema = z\n  .strictObject({\n    reference: referenceSchema.optional(),\n    asset: orRef(artifacts.assetSchema.omit({ type: true })).optional(),\n    environment: environmentOptionsSchema.optional(),\n\n    binary: z\n      .union([\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.binarySchema) }),\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.javaSchema) }),\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.pythonSchema) }),\n        softwareOptionsSchema.extend({ artifact: orRef(artifacts.rSchema) }),\n      ])\n      .optional(), // TODO: reduce nesting: put java, python and r to the level of binary, like conda.\n\n    conda: softwareOptionsSchema\n      .extend({ artifact: orRef(artifacts.condaSchema.omit({ type: true })) })\n      .optional(),\n    docker: softwareOptionsSchema\n      .extend({ artifact: orRef(artifacts.dockerSchema.omit({ type: true })) })\n      .optional(),\n  })\n  .refine(\n    (data) => {\n      const n =\n        util.toInt(data.reference) +\n        util.toInt(data.asset && !data.docker) + // no docker for assets\n        util.toInt(data.binary || (data.binary && data.docker)) + // allow both docker and binary to be set in single entrypoint\n        util.toInt(data.conda || (data.conda && data.docker)) + // allow both docker and conda to be set in single entrypoint\n        util.toInt(data.environment && !data.docker); // no docker for environments\n\n      if (n === 0) {\n        return Boolean(data.docker); // allow separate docker entrypoints (without binary/conda/...)\n      }\n\n      return n === 1;\n    },\n    {\n      message:\n        \"entrypoint cannot point to several packages at once: choose 'reference', 'asset', 'binary', 'environment' or 'docker'\",\n      path: [\"reference | asset | binary | environment | docker\"],\n    },\n  );\nexport type entrypointType = z.infer<typeof entrypointSchema>;\n\n// Full block-software.entrypoints list schema\nexport const entrypointListSchema = z.record(\n  z\n    .string()\n    .regex(/[-_a-z0-9.]/)\n    .describe(\n      \"name of entrypoint descriptor, client should import to use this entrypoint (assets.importSoftware)\",\n    ),\n  entrypointSchema,\n);\nexport type entrypointListType = z.infer<typeof entrypointListSchema>;\n\nexport interface ReferenceEntrypoint {\n  type: \"reference\";\n  name: string;\n  reference: string;\n}\n\nexport interface AssetEntrypoint {\n  type: \"asset\";\n  name: string;\n  artifact: artifacts.withId<artifacts.assetType>;\n}\n\nexport interface SoftwareEntrypoint {\n  type: \"software\";\n  name: string;\n  artifact: artifacts.withId<\n    | artifacts.binaryType\n    | artifacts.condaType\n    | artifacts.javaType\n    | artifacts.pythonType\n    | artifacts.rType\n    | artifacts.dockerType\n  >;\n  cmd: string[];\n  env: string[];\n}\n\nexport interface EnvironmentEntrypoint {\n  type: \"environment\";\n  name: string;\n  artifact: artifacts.withId<artifacts.environmentType>;\n  env: string[];\n}\n\nexport type PackageEntrypoint = AssetEntrypoint | SoftwareEntrypoint | EnvironmentEntrypoint;\nexport type Entrypoint = ReferenceEntrypoint | PackageEntrypoint;\nexport type EntrypointType = Extract<Entrypoint, { type: string }>[\"type\"];\n"],"mappings":";;;;AAIA,MAAM,gBAAgB,EAAE,MACtB,EACG,QAAQ,CACR,MACC,KACA,+FACD,CACJ;AAED,MAAa,6BACX;AAEF,MAAa,kBAAkB,EAC5B,QAAQ,CACR,MACC,4BACA,kFACD;AAEH,MAAM,SAAiC,WACrC,EAAE,MAAM,CACN,EACG,OAAO,8BAA8B,CACrC,SAAS,iDAA+C,EAC3D,OACD,CAAC;AAGJ,MAAa,wBAAwB,EAAE,aAAa;CAClD,KAAK,EACF,MAAM,EAAE,OAAO,oCAAoC,CAAC,CACpD,IAAI,GAAG,EAAE,OAAO,qCAAqC,CAAC,CACtD,QAAQ,QAAQ,IAAI,GAAG,MAAM,IAAI,IAAI,EAAE,OAAO,+CAA+C,CAAC,CAC9F,SACC,kGACD;CACH,SAAS,cACN,UAAU,CACV,SAAS,8DAA8D;CAC3E,CAAC;AAGF,MAAa,2BAA2B,EAAE,aAAa;CACrD,UAAU,MAAA,kBAAkC,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC;CACjE,SAAS,cACN,UAAU,CACV,SACC,sFACD;CACJ,CAAC;AAGF,MAAa,mBAAmB,EAC7B,aAAa;CACZ,WAAW,gBAAgB,UAAU;CACrC,OAAO,MAAA,YAA4B,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC,CAAC,UAAU;CACnE,aAAa,yBAAyB,UAAU;CAEhD,QAAQ,EACL,MAAM;EACL,sBAAsB,OAAO,EAAE,UAAU,MAAMA,aAAuB,EAAE,CAAC;EACzE,sBAAsB,OAAO,EAAE,UAAU,MAAMC,WAAqB,EAAE,CAAC;EACvE,sBAAsB,OAAO,EAAE,UAAU,MAAMC,aAAuB,EAAE,CAAC;EACzE,sBAAsB,OAAO,EAAE,UAAU,MAAMC,QAAkB,EAAE,CAAC;EACrE,CAAC,CACD,UAAU;CAEb,OAAO,sBACJ,OAAO,EAAE,UAAU,MAAA,YAA4B,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CACvE,UAAU;CACb,QAAQ,sBACL,OAAO,EAAE,UAAU,MAAA,aAA6B,KAAK,EAAE,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CACxE,UAAU;CACd,CAAC,CACD,QACE,SAAS;CACR,MAAM,IACJC,MAAW,KAAK,UAAU,GAC1BA,MAAW,KAAK,SAAS,CAAC,KAAK,OAAO,GACtCA,MAAW,KAAK,UAAW,KAAK,UAAU,KAAK,OAAQ,GACvDA,MAAW,KAAK,SAAU,KAAK,SAAS,KAAK,OAAQ,GACrDA,MAAW,KAAK,eAAe,CAAC,KAAK,OAAO;AAE9C,KAAI,MAAM,EACR,QAAO,QAAQ,KAAK,OAAO;AAG7B,QAAO,MAAM;GAEf;CACE,SACE;CACF,MAAM,CAAC,oDAAoD;CAC5D,CACF;AAIH,MAAa,uBAAuB,EAAE,OACpC,EACG,QAAQ,CACR,MAAM,cAAc,CACpB,SACC,qGACD,EACH,iBACD"}