@settlemint/sdk-utils
Version:
Shared utilities and helper functions for SettleMint SDK modules
1 lines • 53.6 kB
Source Map (JSON)
{"version":3,"file":"environment.cjs","names":["output: string","msg: string","message: string","code: number","output: string[]","command: string","args: string[]","options?: ExecuteCommandOptions","data: Buffer | string","msg: string","message: string","level: \"info\" | \"warn\"","title: string","items: Array<string | string[]>","items","msg: string","message: string","originalError: Error","options: SpinnerOptions<R>","error: Error","isInCi","spinner","val: string","s: string","value: string","maxLength: number","title: string","data: unknown[]","table","Table","schema: T","value: unknown","ZodError","ApplicationAccessTokenSchema: ZodString","z","PersonalAccessTokenSchema: ZodString","AccessTokenSchema: ZodString","value: string","defaultValue: T | null","value: unknown","value","z","z","z","z","validateEnv: T","prod: boolean","path: string","cwd?: string","path: PathLike","startDir: string","projectDir: string","workspace: string","packageJsonPath: string","obj: Record<string, unknown>","currentEnv: Record<string, unknown>","env: Partial<DotEnv>"],"sources":["../src/terminal/should-print.ts","../src/terminal/ascii.ts","../src/logging/mask-tokens.ts","../src/terminal/cancel.ts","../src/terminal/execute-command.ts","../src/terminal/intro.ts","../src/terminal/note.ts","../src/terminal/list.ts","../src/terminal/outro.ts","../src/terminal/spinner.ts","../src/string.ts","../src/terminal/table.ts","../src/validation/validate.ts","../src/validation/access-token.schema.ts","../src/json.ts","../src/validation/unique-name.schema.ts","../src/validation/url.schema.ts","../src/validation/dot-env.schema.ts","../src/validation/id.schema.ts","../src/environment/load-env.ts","../src/filesystem/project-root.ts","../src/filesystem/exists.ts","../src/filesystem/mono-repo.ts","../src/environment/write-env.ts"],"sourcesContent":["/**\n * Returns true if the terminal should print, false otherwise.\n * @returns true if the terminal should print, false otherwise.\n */\nexport function shouldPrint() {\n return process.env.SETTLEMINT_DISABLE_TERMINAL !== \"true\";\n}\n","import { magentaBright } from \"yoctocolors\";\nimport { shouldPrint } from \"./should-print.js\";\n\n/**\n * Prints the SettleMint ASCII art logo to the console in magenta color.\n * Used for CLI branding and visual identification.\n *\n * @example\n * import { ascii } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Prints the SettleMint logo\n * ascii();\n */\nexport const ascii = (): void => {\n if (!shouldPrint()) {\n return;\n }\n console.log(\n magentaBright(`\n _________ __ __ .__ _____ .__ __\n / _____/ _____/ |__/ |_| | ____ / \\\\ |__| _____/ |_\n \\\\_____ \\\\_/ __ \\\\ __\\\\ __\\\\ | _/ __ \\\\ / \\\\ / \\\\| |/ \\\\ __\\\\\n / \\\\ ___/| | | | | |_\\\\ ___// Y \\\\ | | \\\\ |\n/_________/\\\\_____>__| |__| |____/\\\\_____>____|____/__|___|__/__|\n`),\n );\n};\n","/**\n * Masks sensitive SettleMint tokens in output text by replacing them with asterisks.\n * Handles personal access tokens (PAT), application access tokens (AAT), and service account tokens (SAT).\n *\n * @param output - The text string that may contain sensitive tokens\n * @returns The text with any sensitive tokens masked with asterisks\n * @example\n * import { maskTokens } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Masks a token in text\n * const masked = maskTokens(\"Token: sm_pat_****\"); // \"Token: ***\"\n */\nexport const maskTokens = (output: string): string => {\n return output.replace(/sm_(pat|aat|sat)_[0-9a-zA-Z]+/g, \"***\");\n};\n","import { maskTokens } from \"@/logging/mask-tokens.js\";\nimport { inverse, redBright } from \"yoctocolors\";\n\n/**\n * Error class used to indicate that the operation was cancelled.\n * This error is used to signal that the operation should be aborted.\n */\nexport class CancelError extends Error {}\n\n/**\n * Displays an error message in red inverse text and throws a CancelError.\n * Used to terminate execution with a visible error message.\n * Any sensitive tokens in the message are masked before display.\n *\n * @param msg - The error message to display\n * @returns never - Function does not return as it throws an error\n * @example\n * import { cancel } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Exits process with error message\n * cancel(\"An error occurred\");\n */\nexport const cancel = (msg: string): never => {\n console.log(\"\");\n console.log(inverse(redBright(maskTokens(msg))));\n console.log(\"\");\n throw new CancelError(msg);\n};\n","import { type SpawnOptionsWithoutStdio, spawn } from \"node:child_process\";\nimport { maskTokens } from \"../logging/mask-tokens.js\";\n\n/**\n * Options for executing a command, extending SpawnOptionsWithoutStdio\n */\nexport interface ExecuteCommandOptions extends SpawnOptionsWithoutStdio {\n /** Whether to suppress output to stdout/stderr */\n silent?: boolean;\n}\n\n/**\n * Error class for command execution errors\n * @extends Error\n */\nexport class CommandError extends Error {\n /**\n * Constructs a new CommandError\n * @param message - The error message\n * @param code - The exit code of the command\n * @param output - The output of the command\n */\n constructor(\n message: string,\n public readonly code: number,\n public readonly output: string[],\n ) {\n super(message);\n }\n}\n\n/**\n * Executes a command with the given arguments in a child process.\n * Pipes stdin to the child process and captures stdout/stderr output.\n * Masks any sensitive tokens in the output before displaying or returning.\n *\n * @param command - The command to execute\n * @param args - Array of arguments to pass to the command\n * @param options - Options for customizing command execution\n * @returns Array of output strings from stdout and stderr\n * @throws {CommandError} If the process fails to start or exits with non-zero code\n * @example\n * import { executeCommand } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Execute git clone\n * await executeCommand(\"git\", [\"clone\", \"repo-url\"]);\n *\n * // Execute silently\n * await executeCommand(\"npm\", [\"install\"], { silent: true });\n */\nexport async function executeCommand(\n command: string,\n args: string[],\n options?: ExecuteCommandOptions,\n): Promise<string[]> {\n const { silent, ...spawnOptions } = options ?? {};\n const child = spawn(command, args, { ...spawnOptions, env: { ...process.env, ...options?.env } });\n process.stdin.pipe(child.stdin);\n const output: string[] = [];\n return new Promise((resolve, reject) => {\n child.stdout.on(\"data\", (data: Buffer | string) => {\n const maskedData = maskTokens(data.toString());\n if (!silent) {\n process.stdout.write(maskedData);\n }\n output.push(maskedData);\n });\n child.stderr.on(\"data\", (data: Buffer | string) => {\n const maskedData = maskTokens(data.toString());\n if (!silent) {\n process.stderr.write(maskedData);\n }\n output.push(maskedData);\n });\n child.on(\"error\", (err) => {\n process.stdin.unpipe(child.stdin);\n reject(new CommandError(err.message, \"code\" in err && typeof err.code === \"number\" ? err.code : 1, output));\n });\n child.on(\"close\", (code) => {\n process.stdin.unpipe(child.stdin);\n if (code === 0 || code === null || code === 143) {\n resolve(output);\n return;\n }\n reject(new CommandError(`Command \"${command}\" exited with code ${code}`, code, output));\n });\n });\n}\n","import { maskTokens } from \"@/logging/mask-tokens.js\";\nimport { magentaBright } from \"yoctocolors\";\nimport { shouldPrint } from \"./should-print.js\";\n\n/**\n * Displays an introductory message in magenta text with padding.\n * Any sensitive tokens in the message are masked before display.\n *\n * @param msg - The message to display as introduction\n * @example\n * import { intro } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Display intro message\n * intro(\"Starting deployment...\");\n */\nexport const intro = (msg: string): void => {\n if (!shouldPrint()) {\n return;\n }\n console.log(\"\");\n console.log(magentaBright(maskTokens(msg)));\n console.log(\"\");\n};\n","import { maskTokens } from \"@/logging/mask-tokens.js\";\nimport { yellowBright } from \"yoctocolors\";\nimport { shouldPrint } from \"./should-print.js\";\n\n/**\n * Displays a note message with optional warning level formatting.\n * Regular notes are displayed in normal text, while warnings are shown in yellow.\n * Any sensitive tokens in the message are masked before display.\n *\n * @param message - The message to display as a note\n * @param level - The note level: \"info\" (default) or \"warn\" for warning styling\n * @example\n * import { note } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Display info note\n * note(\"Operation completed successfully\");\n *\n * // Display warning note\n * note(\"Low disk space remaining\", \"warn\");\n */\nexport const note = (message: string, level: \"info\" | \"warn\" = \"info\"): void => {\n if (!shouldPrint()) {\n return;\n }\n const maskedMessage = maskTokens(message);\n\n console.log(\"\");\n if (level === \"warn\") {\n console.warn(yellowBright(maskedMessage));\n return;\n }\n\n console.log(maskedMessage);\n};\n","import { note } from \"./note.js\";\n\n/**\n * Displays a list of items in a formatted manner, supporting nested items.\n *\n * @param title - The title of the list\n * @param items - The items to display, can be strings or arrays for nested items\n * @returns The formatted list\n * @example\n * import { list } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Simple list\n * list(\"Use cases\", [\"use case 1\", \"use case 2\", \"use case 3\"]);\n *\n * // Nested list\n * list(\"Providers\", [\n * \"AWS\",\n * [\"us-east-1\", \"eu-west-1\"],\n * \"Azure\",\n * [\"eastus\", \"westeurope\"]\n * ]);\n */\nexport function list(title: string, items: Array<string | string[]>) {\n const formatItems = (items: Array<string | string[]>): string => {\n return items\n .map((item) => {\n if (Array.isArray(item)) {\n return item.map((subItem) => ` • ${subItem}`).join(\"\\n\");\n }\n return ` • ${item}`;\n })\n .join(\"\\n\");\n };\n\n return note(`${title}:\\n\\n${formatItems(items)}`);\n}\n","import { maskTokens } from \"@/logging/mask-tokens.js\";\nimport { shouldPrint } from \"@/terminal/should-print.js\";\nimport { greenBright, inverse } from \"yoctocolors\";\n\n/**\n * Displays a closing message in green inverted text with padding.\n * Any sensitive tokens in the message are masked before display.\n *\n * @param msg - The message to display as conclusion\n * @example\n * import { outro } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Display outro message\n * outro(\"Deployment completed successfully!\");\n */\nexport const outro = (msg: string): void => {\n if (!shouldPrint()) {\n return;\n }\n console.log(\"\");\n console.log(inverse(greenBright(maskTokens(msg))));\n console.log(\"\");\n};\n","import isInCi from \"is-in-ci\";\nimport yoctoSpinner, { type Spinner } from \"yocto-spinner\";\nimport { redBright } from \"yoctocolors\";\nimport { maskTokens } from \"../logging/mask-tokens.js\";\nimport { note } from \"./note.js\";\nimport { shouldPrint } from \"./should-print.js\";\n\n/**\n * Error class used to indicate that the spinner operation failed.\n * This error is used to signal that the operation should be aborted.\n */\nexport class SpinnerError extends Error {\n constructor(\n message: string,\n public readonly originalError: Error,\n ) {\n super(message);\n this.name = \"SpinnerError\";\n }\n}\n\n/**\n * Options for configuring the spinner behavior\n */\nexport interface SpinnerOptions<R> {\n /** Message to display when spinner starts */\n startMessage: string;\n /** Async task to execute while spinner is active */\n task: (spinner?: Spinner) => Promise<R>;\n /** Message to display when spinner completes successfully */\n stopMessage: string;\n}\n\n/**\n * Displays a loading spinner while executing an async task.\n * Shows progress with start/stop messages and handles errors.\n * Spinner is disabled in CI environments.\n *\n * @param options - Configuration options for the spinner\n * @returns The result from the executed task\n * @throws Will exit process with code 1 if task fails\n * @example\n * import { spinner } from \"@settlemint/sdk-utils/terminal\";\n *\n * // Show spinner during async task\n * const result = await spinner({\n * startMessage: \"Deploying...\",\n * task: async () => {\n * // Async work here\n * return \"success\";\n * },\n * stopMessage: \"Deployed successfully!\"\n * });\n */\nexport const spinner = async <R>(options: SpinnerOptions<R>): Promise<R> => {\n const handleError = (error: Error) => {\n const errorMessage = maskTokens(error.message);\n note(redBright(`${errorMessage}\\n\\n${error.stack}`));\n throw new SpinnerError(errorMessage, error);\n };\n if (isInCi || !shouldPrint()) {\n try {\n return await options.task();\n } catch (err) {\n return handleError(err as Error);\n }\n }\n const spinner = yoctoSpinner({ stream: process.stdout }).start(options.startMessage);\n try {\n const result = await options.task(spinner);\n spinner.success(options.stopMessage);\n // Ensure spinner success message renders before proceeding to avoid\n // terminal output overlap issues with subsequent messages\n await new Promise((resolve) => process.nextTick(resolve));\n return result;\n } catch (err) {\n spinner.error(redBright(`${options.startMessage} --> Error!`));\n return handleError(err as Error);\n }\n};\n","/**\n * Capitalizes the first letter of a string.\n *\n * @param val - The string to capitalize\n * @returns The input string with its first letter capitalized\n *\n * @example\n * import { capitalizeFirstLetter } from \"@settlemint/sdk-utils\";\n *\n * const capitalized = capitalizeFirstLetter(\"hello\");\n * // Returns: \"Hello\"\n */\nexport function capitalizeFirstLetter(val: string) {\n return String(val).charAt(0).toUpperCase() + String(val).slice(1);\n}\n\n/**\n * Converts a camelCase string to a human-readable string.\n *\n * @param s - The camelCase string to convert\n * @returns The human-readable string\n *\n * @example\n * import { camelCaseToWords } from \"@settlemint/sdk-utils\";\n *\n * const words = camelCaseToWords(\"camelCaseString\");\n * // Returns: \"Camel Case String\"\n */\nexport function camelCaseToWords(s: string) {\n const result = s.replace(/([a-z])([A-Z])/g, \"$1 $2\");\n const withSpaces = result.replace(/([A-Z])([a-z])/g, \" $1$2\");\n const capitalized = capitalizeFirstLetter(withSpaces);\n return capitalized.replace(/\\s+/g, \" \").trim();\n}\n\n/**\n * Replaces underscores and hyphens with spaces.\n *\n * @param s - The string to replace underscores and hyphens with spaces\n * @returns The input string with underscores and hyphens replaced with spaces\n *\n * @example\n * import { replaceUnderscoresAndHyphensWithSpaces } from \"@settlemint/sdk-utils\";\n *\n * const result = replaceUnderscoresAndHyphensWithSpaces(\"Already_Spaced-Second\");\n * // Returns: \"Already Spaced Second\"\n */\nexport function replaceUnderscoresAndHyphensWithSpaces(s: string) {\n return s.replace(/[-_]/g, \" \");\n}\n\n/**\n * Truncates a string to a maximum length and appends \"...\" if it is longer.\n *\n * @param value - The string to truncate\n * @param maxLength - The maximum length of the string\n * @returns The truncated string or the original string if it is shorter than the maximum length\n *\n * @example\n * import { truncate } from \"@settlemint/sdk-utils\";\n *\n * const truncated = truncate(\"Hello, world!\", 10);\n * // Returns: \"Hello, wor...\"\n */\nexport function truncate(value: string, maxLength: number) {\n if (value.length <= maxLength) {\n return value;\n }\n return `${value.slice(0, maxLength)}...`;\n}\n","import { Table } from \"console-table-printer\";\nimport { whiteBright } from \"yoctocolors\";\nimport { camelCaseToWords } from \"@/string.js\";\nimport { note } from \"./note.js\";\nimport { shouldPrint } from \"./should-print.js\";\n/**\n * Displays data in a formatted table in the terminal.\n *\n * @param title - Title to display above the table\n * @param data - Array of objects to display in table format\n * @example\n * import { table } from \"@settlemint/sdk-utils/terminal\";\n *\n * const data = [\n * { name: \"Item 1\", value: 100 },\n * { name: \"Item 2\", value: 200 }\n * ];\n *\n * table(\"My Table\", data);\n */\nexport function table(title: string, data: unknown[]): void {\n if (!shouldPrint()) {\n return;\n }\n\n note(title);\n\n if (!data || data.length === 0) {\n note(\"No data to display\");\n return;\n }\n\n const columnKeys = Object.keys(data[0] as Record<string, unknown>);\n const table = new Table({\n columns: columnKeys.map((key) => ({\n name: key,\n title: whiteBright(camelCaseToWords(key)),\n alignment: \"left\",\n })),\n });\n table.addRows(data as Array<Record<string, any>>);\n table.printTable();\n}\n","import { ZodError, type ZodType } from \"zod\";\n\n/**\n * Validates a value against a given Zod schema.\n *\n * @param schema - The Zod schema to validate against.\n * @param value - The value to validate.\n * @returns The validated and parsed value.\n * @throws Will throw an error if validation fails, with formatted error messages.\n *\n * @example\n * import { validate } from \"@settlemint/sdk-utils/validation\";\n *\n * const validatedId = validate(IdSchema, \"550e8400-e29b-41d4-a716-446655440000\");\n */\nexport function validate<T extends ZodType>(schema: T, value: unknown): T[\"_output\"] {\n try {\n return schema.parse(value);\n } catch (error) {\n if (error instanceof ZodError) {\n const formattedErrors = error.issues.map((err) => `- ${err.path.join(\".\")}: ${err.message}`).join(\"\\n\");\n throw new Error(`Validation error${error.issues.length > 1 ? \"s\" : \"\"}:\\n${formattedErrors}`);\n }\n throw error; // Re-throw if it's not a ZodError\n }\n}\n","import { type ZodString, z } from \"zod\";\n\n/**\n * Schema for validating application access tokens.\n * Application access tokens start with 'sm_aat_' prefix.\n */\nexport const ApplicationAccessTokenSchema: ZodString = z.string().regex(/^sm_aat_.+$/);\nexport type ApplicationAccessToken = z.infer<typeof ApplicationAccessTokenSchema>;\n\n/**\n * Schema for validating personal access tokens.\n * Personal access tokens start with 'sm_pat_' prefix.\n */\nexport const PersonalAccessTokenSchema: ZodString = z.string().regex(/^sm_pat_.+$/);\nexport type PersonalAccessToken = z.infer<typeof PersonalAccessTokenSchema>;\n\n/**\n * Schema for validating both application and personal access tokens.\n * Accepts tokens starting with either 'sm_pat_' or 'sm_aat_' prefix.\n */\nexport const AccessTokenSchema: ZodString = z.string().regex(/^(sm_pat_.+|sm_aat_.+)$/);\nexport type AccessToken = z.infer<typeof AccessTokenSchema>;\n","/**\n * Attempts to parse a JSON string into a typed value, returning a default value if parsing fails.\n *\n * @param value - The JSON string to parse\n * @param defaultValue - The value to return if parsing fails or results in null/undefined\n * @returns The parsed JSON value as type T, or the default value if parsing fails\n *\n * @example\n * import { tryParseJson } from \"@settlemint/sdk-utils\";\n *\n * const config = tryParseJson<{ port: number }>(\n * '{\"port\": 3000}',\n * { port: 8080 }\n * );\n * // Returns: { port: 3000 }\n *\n * const invalid = tryParseJson<string[]>(\n * 'invalid json',\n * []\n * );\n * // Returns: []\n */\nexport function tryParseJson<T>(value: string, defaultValue: T | null = null): T | null {\n try {\n const parsed = JSON.parse(value) as T;\n if (parsed === undefined || parsed === null) {\n return defaultValue;\n }\n return parsed;\n } catch (_err) {\n // Invalid json\n return defaultValue;\n }\n}\n\n/**\n * Extracts a JSON object from a string.\n *\n * @param value - The string to extract the JSON object from\n * @returns The parsed JSON object, or null if no JSON object is found\n * @throws {Error} If the input string is too long (longer than 5000 characters)\n * @example\n * import { extractJsonObject } from \"@settlemint/sdk-utils\";\n *\n * const json = extractJsonObject<{ port: number }>(\n * 'port info: {\"port\": 3000}',\n * );\n * // Returns: { port: 3000 }\n */\nexport function extractJsonObject<T>(value: string): T | null {\n if (value.length > 5000) {\n throw new Error(\"Input too long\");\n }\n const result = /\\{([\\s\\S]*)\\}/.exec(value);\n if (!result) {\n return null;\n }\n return tryParseJson<T>(result[0]);\n}\n\n/**\n * Converts a value to a JSON stringifiable format.\n *\n * @param value - The value to convert\n * @returns The JSON stringifiable value\n *\n * @example\n * import { makeJsonStringifiable } from \"@settlemint/sdk-utils\";\n *\n * const json = makeJsonStringifiable<{ amount: bigint }>({ amount: BigInt(1000) });\n * // Returns: '{\"amount\":\"1000\"}'\n */\nexport function makeJsonStringifiable<T>(value: unknown): T {\n if (value === undefined || value === null) {\n return value as T;\n }\n return tryParseJson<T>(\n JSON.stringify(\n value,\n (_, value) => (typeof value === \"bigint\" ? value.toString() : value), // return everything else unchanged\n ),\n ) as T;\n}\n","import { z } from \"zod\";\n\n/**\n * Schema for validating unique names used across the SettleMint platform.\n * Only accepts lowercase alphanumeric characters and hyphens.\n * Used for workspace names, application names, service names etc.\n *\n * @example\n * import { UniqueNameSchema } from \"@settlemint/sdk-utils/validation\";\n *\n * // Validate a workspace name\n * const isValidName = UniqueNameSchema.safeParse(\"my-workspace-123\").success;\n * // true\n *\n * // Invalid names will fail validation\n * const isInvalidName = UniqueNameSchema.safeParse(\"My Workspace!\").success;\n * // false\n */\nexport const UniqueNameSchema = z.string().regex(/^[a-z0-9-]+$/);\n\n/**\n * Type definition for unique names, inferred from UniqueNameSchema.\n */\nexport type UniqueName = z.infer<typeof UniqueNameSchema>;\n","import { z } from \"zod\";\n\n/**\n * Schema for validating URLs.\n *\n * @example\n * import { UrlSchema } from \"@settlemint/sdk-utils/validation\";\n *\n * // Validate a URL\n * const isValidUrl = UrlSchema.safeParse(\"https://console.settlemint.com\").success;\n * // true\n *\n * // Invalid URLs will fail validation\n * const isInvalidUrl = UrlSchema.safeParse(\"not-a-url\").success;\n * // false\n */\nexport const UrlSchema = z.string().url();\nexport type Url = z.infer<typeof UrlSchema>;\n\n/**\n * Schema for validating URL paths.\n *\n * @example\n * import { UrlPathSchema } from \"@settlemint/sdk-utils/validation\";\n *\n * // Validate a URL path\n * const isValidPath = UrlPathSchema.safeParse(\"/api/v1/users\").success;\n * // true\n *\n * // Invalid paths will fail validation\n * const isInvalidPath = UrlPathSchema.safeParse(\"not-a-path\").success;\n * // false\n */\nexport const UrlPathSchema = z.string().regex(/^\\/(?:[a-zA-Z0-9-_]+(?:\\/[a-zA-Z0-9-_]+)*\\/?)?$/, {\n message: \"Invalid URL path format. Must start with '/' and can contain letters, numbers, hyphens, and underscores.\",\n});\n\nexport type UrlPath = z.infer<typeof UrlPathSchema>;\n\n/**\n * Schema that accepts either a full URL or a URL path.\n *\n * @example\n * import { UrlOrPathSchema } from \"@settlemint/sdk-utils/validation\";\n *\n * // Validate a URL\n * const isValidUrl = UrlOrPathSchema.safeParse(\"https://console.settlemint.com\").success;\n * // true\n *\n * // Validate a path\n * const isValidPath = UrlOrPathSchema.safeParse(\"/api/v1/users\").success;\n * // true\n */\nexport const UrlOrPathSchema = z.union([UrlSchema, UrlPathSchema]);\nexport type UrlOrPath = z.infer<typeof UrlOrPathSchema>;\n","import { z } from \"zod\";\nimport { tryParseJson } from \"@/json.js\";\nimport { ApplicationAccessTokenSchema, PersonalAccessTokenSchema } from \"./access-token.schema.js\";\nimport { UniqueNameSchema } from \"./unique-name.schema.js\";\nimport { UrlSchema } from \"./url.schema.js\";\n\n/**\n * Use this value to indicate that the resources are not part of the SettleMint platform.\n */\nexport const STANDALONE_INSTANCE = \"standalone\";\n/**\n * Use this value to indicate that the resources are not part of the SettleMint platform.\n */\nexport const LOCAL_INSTANCE = \"local\";\n\n/**\n * Schema for validating environment variables used by the SettleMint SDK.\n * Defines validation rules and types for configuration values like URLs,\n * access tokens, workspace names, and service endpoints.\n */\nexport const DotEnvSchema = z.object({\n /** Base URL of the SettleMint platform instance, set to standalone if your resources are not part of the SettleMint platform */\n SETTLEMINT_INSTANCE: z\n .union([UrlSchema, z.literal(STANDALONE_INSTANCE), z.literal(LOCAL_INSTANCE)])\n .default(\"https://console.settlemint.com\"),\n /** Application access token for authenticating with SettleMint services */\n SETTLEMINT_ACCESS_TOKEN: ApplicationAccessTokenSchema.optional(),\n /** @internal */\n SETTLEMINT_PERSONAL_ACCESS_TOKEN: PersonalAccessTokenSchema.optional(),\n /** Unique name of the workspace */\n SETTLEMINT_WORKSPACE: UniqueNameSchema.optional(),\n /** Unique name of the application */\n SETTLEMINT_APPLICATION: UniqueNameSchema.optional(),\n /** Unique name of the blockchain network */\n SETTLEMINT_BLOCKCHAIN_NETWORK: UniqueNameSchema.optional(),\n /** Chain ID of the blockchain network */\n SETTLEMINT_BLOCKCHAIN_NETWORK_CHAIN_ID: z.string().optional(),\n /** Unique name of the blockchain node (should have a private key for signing transactions) */\n SETTLEMINT_BLOCKCHAIN_NODE: UniqueNameSchema.optional(),\n /** JSON RPC endpoint for the blockchain node */\n SETTLEMINT_BLOCKCHAIN_NODE_JSON_RPC_ENDPOINT: UrlSchema.optional(),\n /** Unique name of the blockchain node or load balancer */\n SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER: UniqueNameSchema.optional(),\n /** JSON RPC endpoint for the blockchain node or load balancer */\n SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER_JSON_RPC_ENDPOINT: UrlSchema.optional(),\n /** Unique name of the Hasura instance */\n SETTLEMINT_HASURA: UniqueNameSchema.optional(),\n /** Endpoint URL for the Hasura GraphQL API */\n SETTLEMINT_HASURA_ENDPOINT: UrlSchema.optional(),\n /** Admin secret for authenticating with Hasura */\n SETTLEMINT_HASURA_ADMIN_SECRET: z.string().optional(),\n /** Database connection URL for Hasura */\n SETTLEMINT_HASURA_DATABASE_URL: z.string().optional(),\n /** Unique name of The Graph instance */\n SETTLEMINT_THEGRAPH: UniqueNameSchema.optional(),\n /** Array of endpoint URLs for The Graph subgraphs */\n SETTLEMINT_THEGRAPH_SUBGRAPHS_ENDPOINTS: z.preprocess(\n (value) => tryParseJson(value as string, []),\n z.array(UrlSchema).optional(),\n ),\n /** Default The Graph subgraph to use */\n SETTLEMINT_THEGRAPH_DEFAULT_SUBGRAPH: z.string().optional(),\n /** Unique name of the Smart Contract Portal instance */\n SETTLEMINT_PORTAL: UniqueNameSchema.optional(),\n /** GraphQL endpoint URL for the Portal */\n SETTLEMINT_PORTAL_GRAPHQL_ENDPOINT: UrlSchema.optional(),\n /** REST endpoint URL for the Portal */\n SETTLEMINT_PORTAL_REST_ENDPOINT: UrlSchema.optional(),\n /** WebSocket endpoint URL for the Portal */\n SETTLEMINT_PORTAL_WS_ENDPOINT: UrlSchema.optional(),\n /** Unique name of the HD private key */\n SETTLEMINT_HD_PRIVATE_KEY: UniqueNameSchema.optional(),\n /** Address of the HD private key forwarder */\n SETTLEMINT_HD_PRIVATE_KEY_FORWARDER_ADDRESS: z.string().optional(),\n /** Unique name of the accessible private key */\n SETTLEMINT_ACCESSIBLE_PRIVATE_KEY: UniqueNameSchema.optional(),\n /** Unique name of the MinIO instance */\n SETTLEMINT_MINIO: UniqueNameSchema.optional(),\n /** Endpoint URL for MinIO */\n SETTLEMINT_MINIO_ENDPOINT: UrlSchema.optional(),\n /** Access key for MinIO authentication */\n SETTLEMINT_MINIO_ACCESS_KEY: z.string().optional(),\n /** Secret key for MinIO authentication */\n SETTLEMINT_MINIO_SECRET_KEY: z.string().optional(),\n /** Unique name of the IPFS instance */\n SETTLEMINT_IPFS: UniqueNameSchema.optional(),\n /** API endpoint URL for IPFS */\n SETTLEMINT_IPFS_API_ENDPOINT: UrlSchema.optional(),\n /** Pinning service endpoint URL for IPFS */\n SETTLEMINT_IPFS_PINNING_ENDPOINT: UrlSchema.optional(),\n /** Gateway endpoint URL for IPFS */\n SETTLEMINT_IPFS_GATEWAY_ENDPOINT: UrlSchema.optional(),\n /** Unique name of the custom deployment */\n SETTLEMINT_CUSTOM_DEPLOYMENT: UniqueNameSchema.optional(),\n /** Endpoint URL for the custom deployment */\n SETTLEMINT_CUSTOM_DEPLOYMENT_ENDPOINT: UrlSchema.optional(),\n /** Unique name of the Blockscout instance */\n SETTLEMINT_BLOCKSCOUT: UniqueNameSchema.optional(),\n /** GraphQL endpoint URL for Blockscout */\n SETTLEMINT_BLOCKSCOUT_GRAPHQL_ENDPOINT: UrlSchema.optional(),\n /** UI endpoint URL for Blockscout */\n SETTLEMINT_BLOCKSCOUT_UI_ENDPOINT: UrlSchema.optional(),\n /** Name of the new project being created */\n SETTLEMINT_NEW_PROJECT_NAME: z.string().optional(),\n /** The log level to use */\n SETTLEMINT_LOG_LEVEL: z.enum([\"debug\", \"info\", \"warn\", \"error\", \"none\"]).default(\"warn\"),\n});\n\n/**\n * Type definition for the environment variables schema.\n */\nexport type DotEnv = z.infer<typeof DotEnvSchema>;\n\n/**\n * Partial version of the environment variables schema where all fields are optional.\n * Useful for validating incomplete configurations during development or build time.\n */\nexport const DotEnvSchemaPartial = DotEnvSchema.partial();\n\n/**\n * Type definition for the partial environment variables schema.\n */\nexport type DotEnvPartial = z.infer<typeof DotEnvSchemaPartial>;\n","import { z } from \"zod\";\n\n/**\n * Schema for validating database IDs. Accepts both PostgreSQL UUIDs and MongoDB ObjectIDs.\n * PostgreSQL UUIDs are 32 hexadecimal characters with hyphens (e.g. 123e4567-e89b-12d3-a456-426614174000).\n * MongoDB ObjectIDs are 24 hexadecimal characters (e.g. 507f1f77bcf86cd799439011).\n *\n * @example\n * import { IdSchema } from \"@settlemint/sdk-utils/validation\";\n *\n * // Validate PostgreSQL UUID\n * const isValidUuid = IdSchema.safeParse(\"123e4567-e89b-12d3-a456-426614174000\").success;\n *\n * // Validate MongoDB ObjectID\n * const isValidObjectId = IdSchema.safeParse(\"507f1f77bcf86cd799439011\").success;\n */\nexport const IdSchema = z.union([\n z\n .string()\n .uuid(), // PostgreSQL UUID\n z\n .string()\n .regex(/^[0-9a-fA-F]{24}$/), // MongoDB ObjectID\n]);\n\n/**\n * Type definition for database IDs, inferred from IdSchema.\n * Can be either a PostgreSQL UUID string or MongoDB ObjectID string.\n */\nexport type Id = z.infer<typeof IdSchema>;\n","import { join } from \"node:path\";\nimport { cancel } from \"@/terminal.js\";\nimport { type DotEnv, type DotEnvPartial, DotEnvSchema, DotEnvSchemaPartial, validate } from \"@/validation.js\";\nimport { config } from \"@dotenvx/dotenvx\";\n\n/**\n * Loads environment variables from .env files.\n * To enable encryption with dotenvx (https://www.dotenvx.com/docs) run `bunx dotenvx encrypt`\n *\n * @param validateEnv - Whether to validate the environment variables against the schema\n * @param prod - Whether to load production environment variables\n * @param path - Optional path to the directory containing .env files. Defaults to process.cwd()\n * @returns A promise that resolves to the validated environment variables\n * @throws Will throw an error if validation fails and validateEnv is true\n * @example\n * import { loadEnv } from '@settlemint/sdk-utils/environment';\n *\n * // Load and validate environment variables\n * const env = await loadEnv(true, false);\n * console.log(env.SETTLEMINT_INSTANCE);\n *\n * // Load without validation\n * const rawEnv = await loadEnv(false, false);\n */\nexport async function loadEnv<T extends boolean = true>(\n validateEnv: T,\n prod: boolean,\n path: string = process.cwd(),\n): Promise<T extends true ? DotEnv : DotEnvPartial> {\n return loadEnvironmentEnv(validateEnv, !!prod, path);\n}\n\nasync function loadEnvironmentEnv<T extends boolean = true>(\n validateEnv: T,\n prod: boolean,\n path: string = process.cwd(),\n): Promise<T extends true ? DotEnv : DotEnvPartial> {\n if (prod) {\n process.env.NODE_ENV = \"production\";\n }\n let { parsed } = config({\n convention: \"nextjs\",\n logLevel: \"error\",\n overload: true,\n quiet: true,\n path: [join(path, \".env\"), join(path, \".env.local\")],\n });\n\n if (!parsed) {\n parsed = {};\n }\n const defaultEnv = Object.fromEntries(\n Object.entries(process.env).filter(([_, value]) => typeof value === \"string\" && value !== \"\"),\n ) as Record<string, string>;\n try {\n return validate(validateEnv ? DotEnvSchema : DotEnvSchemaPartial, {\n ...parsed,\n ...defaultEnv,\n }) as T extends true ? DotEnv : DotEnvPartial;\n } catch (error) {\n cancel((error as Error).message);\n return {} as T extends true ? DotEnv : DotEnvPartial;\n }\n}\n","import { dirname } from \"node:path\";\nimport { findUp } from \"find-up\";\n\n/**\n * Finds the root directory of the current project by locating the nearest package.json file\n *\n * @param fallbackToCwd - If true, will return the current working directory if no package.json is found\n * @param cwd - The directory to start searching for the package.json file from (defaults to process.cwd())\n * @returns Promise that resolves to the absolute path of the project root directory\n * @throws Will throw an error if no package.json is found in the directory tree\n * @example\n * import { projectRoot } from \"@settlemint/sdk-utils/filesystem\";\n *\n * // Get project root path\n * const rootDir = await projectRoot();\n * console.log(`Project root is at: ${rootDir}`);\n */\nexport async function projectRoot(fallbackToCwd = false, cwd?: string): Promise<string> {\n const packageJsonPath = await findUp(\"package.json\", { cwd });\n if (!packageJsonPath) {\n if (fallbackToCwd) {\n return process.cwd();\n }\n throw new Error(\"Unable to find project root (no package.json found)\");\n }\n return dirname(packageJsonPath);\n}\n","import type { PathLike } from \"node:fs\";\nimport { stat } from \"node:fs/promises\";\n\n/**\n * Checks if a file or directory exists at the given path\n *\n * @param path - The file system path to check for existence\n * @returns Promise that resolves to true if the path exists, false otherwise\n * @example\n * import { exists } from \"@settlemint/sdk-utils/filesystem\";\n *\n * // Check if file exists before reading\n * if (await exists('/path/to/file.txt')) {\n * // File exists, safe to read\n * }\n */\nexport async function exists(path: PathLike): Promise<boolean> {\n try {\n await stat(path);\n return true;\n } catch {\n return false;\n }\n}\n","import { readFile } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\nimport { findUp } from \"find-up\";\nimport { glob } from \"glob\";\nimport { exists } from \"@/filesystem.js\";\nimport { tryParseJson } from \"@/json.js\";\n\n/**\n * Finds the root directory of a monorepo\n *\n * @param startDir - The directory to start searching from\n * @returns The root directory of the monorepo or null if not found\n * @example\n * import { findMonoRepoRoot } from \"@settlemint/sdk-utils/filesystem\";\n *\n * const root = await findMonoRepoRoot(\"/path/to/your/project\");\n * console.log(root); // Output: /path/to/your/project/packages/core\n */\nexport async function findMonoRepoRoot(startDir: string): Promise<string | null> {\n const lockFilePath = await findUp([\"package-lock.json\", \"yarn.lock\", \"pnpm-lock.yaml\", \"bun.lockb\", \"bun.lock\"], {\n cwd: startDir,\n });\n if (lockFilePath) {\n const packageJsonPath = join(dirname(lockFilePath), \"package.json\");\n const hasWorkSpaces = await packageJsonHasWorkspaces(packageJsonPath);\n return hasWorkSpaces ? dirname(lockFilePath) : null;\n }\n\n let currentDir = startDir;\n\n while (currentDir !== \"/\") {\n const packageJsonPath = join(currentDir, \"package.json\");\n\n if (await packageJsonHasWorkspaces(packageJsonPath)) {\n return currentDir;\n }\n\n const parentDir = dirname(currentDir);\n if (parentDir === currentDir) {\n break; // We've reached the root\n }\n currentDir = parentDir;\n }\n\n return null;\n}\n\n/**\n * Finds all packages in a monorepo\n *\n * @param projectDir - The directory to start searching from\n * @returns An array of package directories\n * @example\n * import { findMonoRepoPackages } from \"@settlemint/sdk-utils/filesystem\";\n *\n * const packages = await findMonoRepoPackages(\"/path/to/your/project\");\n * console.log(packages); // Output: [\"/path/to/your/project/packages/core\", \"/path/to/your/project/packages/ui\"]\n */\nexport async function findMonoRepoPackages(projectDir: string): Promise<string[]> {\n try {\n const monoRepoRoot = await findMonoRepoRoot(projectDir);\n if (!monoRepoRoot) {\n return [projectDir];\n }\n\n const packageJsonPath = join(monoRepoRoot, \"package.json\");\n const packageJson = tryParseJson<{ workspaces: string[] }>(await readFile(packageJsonPath, \"utf-8\"));\n const workspaces = packageJson?.workspaces ?? [];\n\n const packagePaths = await Promise.all(\n workspaces.map(async (workspace: string) => {\n const matches = await glob(join(monoRepoRoot, workspace, \"package.json\"));\n return matches.map((match) => join(match, \"..\"));\n }),\n );\n\n const allPaths = packagePaths.flat();\n // If no packages found in workspaces, treat as non-monorepo\n return allPaths.length === 0 ? [projectDir] : [monoRepoRoot, ...allPaths];\n } catch (_error) {\n // If any error occurs, treat as non-monorepo\n return [projectDir];\n }\n}\n\nasync function packageJsonHasWorkspaces(packageJsonPath: string): Promise<boolean> {\n if (await exists(packageJsonPath)) {\n const packageJson = tryParseJson<{ workspaces: string[] }>(await readFile(packageJsonPath, \"utf-8\"));\n if (packageJson?.workspaces && Array.isArray(packageJson?.workspaces) && packageJson?.workspaces.length > 0) {\n return true;\n }\n }\n return false;\n}\n","import { writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { exists, projectRoot } from \"@/filesystem.js\";\nimport type { DotEnv } from \"@/validation.js\";\nimport { DotEnvSchema } from \"@/validation/dot-env.schema.js\";\nimport { config } from \"@dotenvx/dotenvx\";\nimport { deepmerge } from \"deepmerge-ts\";\nimport { findMonoRepoPackages } from \"../filesystem/mono-repo.js\";\n\n/**\n * Writes environment variables to .env files across a project or monorepo\n *\n * @param options - The options for writing the environment variables\n * @param options.prod - Whether to write production environment variables\n * @param options.env - The environment variables to write\n * @param options.secrets - Whether to write to .env.local files for secrets\n * @param options.cwd - The directory to start searching for the package.json file from (defaults to process.cwd())\n * @returns Promise that resolves when writing is complete\n * @throws Will throw an error if writing fails\n * @example\n * import { writeEnv } from '@settlemint/sdk-utils/environment';\n *\n * // Write development environment variables\n * await writeEnv({\n * prod: false,\n * env: {\n * SETTLEMINT_INSTANCE: 'https://dev.example.com'\n * },\n * secrets: false\n * });\n *\n * // Write production secrets\n * await writeEnv({\n * prod: true,\n * env: {\n * SETTLEMINT_ACCESS_TOKEN: 'secret-token'\n * },\n * secrets: true\n * });\n */\nexport async function writeEnv({\n prod,\n env,\n secrets,\n cwd,\n}: {\n prod: boolean;\n env: Partial<DotEnv>;\n secrets: boolean;\n cwd?: string;\n}): Promise<void> {\n const projectDir = await projectRoot(true, cwd);\n\n if (prod) {\n process.env.NODE_ENV = \"production\";\n }\n\n const targetDirs = await findMonoRepoPackages(projectDir);\n\n await Promise.all(\n targetDirs.map(async (dir) => {\n const envFile = join(\n dir,\n secrets ? `.env${prod ? \".production\" : \"\"}.local` : `.env${prod ? \".production\" : \"\"}`,\n );\n\n let { parsed: currentEnv } = (await exists(envFile))\n ? config({\n path: envFile,\n logLevel: \"error\",\n quiet: true,\n })\n : { parsed: {} };\n\n if (!currentEnv) {\n currentEnv = {};\n }\n\n const prunedEnv = pruneCurrentEnv(currentEnv, env);\n const mergedEnv = deepmerge(prunedEnv, env as Record<string, unknown>);\n await writeFile(envFile, stringify(mergedEnv));\n }),\n );\n}\n\nconst quote = /[\\s\"'#]/;\n\nfunction stringifyPair([key, val]: [string, unknown]): string | undefined {\n if (val === undefined) {\n return undefined;\n }\n if (val === null) {\n return `${key}=\"\"`;\n }\n\n const type = typeof val;\n if (type === \"string\") {\n return `${key}=${quote.test(val as string) ? JSON.stringify(val) : val}`;\n }\n if (type === \"boolean\" || type === \"number\") {\n return `${key}=${val}`;\n }\n if (type === \"object\") {\n return `${key}=${JSON.stringify(val)}`;\n }\n\n throw new Error(`Unsupported type for key \"${key}\": ${type}`);\n}\n\nfunction stringify(obj: Record<string, unknown>): string {\n return Object.entries(obj)\n .sort(([a], [b]) => a.localeCompare(b))\n .map(stringifyPair)\n .filter((value) => value !== undefined)\n .join(\"\\n\");\n}\n\n/**\n * Prunes the current environment variables from the new environment variables\n *\n * @param currentEnv - The current environment variables\n * @param env - The new environment variables\n * @returns The new environment variables with the current environment variables removed\n */\nfunction pruneCurrentEnv(currentEnv: Record<string, unknown>, env: Partial<DotEnv>): Record<string, unknown> {\n const dotEnvKeys = Object.keys(DotEnvSchema.shape);\n return Object.fromEntries(\n Object.entries(currentEnv).filter(([key]) => {\n if (dotEnvKeys.includes(key) && !env[key as keyof typeof env]) {\n return false;\n }\n return true;\n }),\n );\n}\n"],"mappings":"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