@barekey/sdk 0.1.0

package/dist/errors.js

@@ -0,0 +1,343 @@
+const INT64_MIN = BigInt("-9223372036854775808");
+const INT64_MAX = BigInt("9223372036854775807");
+const ERROR_DESCRIPTORS = {
+    FS_NOT_AVAILABLE: {
+        code: "FS_NOT_AVAILABLE",
+        name: "FsNotAvailableError",
+        description: "A filesystem is not available.",
+    },
+    NO_CONFIGURATION_PROVIDED: {
+        code: "NO_CONFIGURATION_PROVIDED",
+        name: "NoConfigurationProvidedError",
+        description: "No Barekey configuration was provided.",
+    },
+    INVALID_CONFIGURATION_PROVIDED: {
+        code: "INVALID_CONFIGURATION_PROVIDED",
+        name: "InvalidConfigurationProvidedError",
+        description: "Invalid Barekey configuration was provided.",
+    },
+    NO_CREDENTIALS_PROVIDED: {
+        code: "NO_CREDENTIALS_PROVIDED",
+        name: "NoCredentialsProvidedError",
+        description: "No Barekey credentials were provided.",
+    },
+    INVALID_CREDENTIALS_PROVIDED: {
+        code: "INVALID_CREDENTIALS_PROVIDED",
+        name: "InvalidCredentialsProvidedError",
+        description: "Invalid Barekey credentials were provided.",
+    },
+    INVALID_DYNAMIC_OPTIONS: {
+        code: "INVALID_DYNAMIC_OPTIONS",
+        name: "InvalidDynamicOptionsError",
+        description: "Invalid dynamic options were provided.",
+    },
+    REQUIREMENTS_VALIDATION_FAILED: {
+        code: "REQUIREMENTS_VALIDATION_FAILED",
+        name: "RequirementsValidationFailedError",
+        description: "Barekey requirements validation failed.",
+    },
+    NETWORK_ERROR: {
+        code: "NETWORK_ERROR",
+        name: "NetworkError",
+        description: "A Barekey network request failed.",
+    },
+    COERCE_FAILED: {
+        code: "COERCE_FAILED",
+        name: "CoerceFailedError",
+        description: "Barekey could not coerce the resolved value.",
+    },
+    TEMPORAL_NOT_AVAILABLE: {
+        code: "TEMPORAL_NOT_AVAILABLE",
+        name: "TemporalNotAvailableError",
+        description: "Temporal is not available in this runtime.",
+    },
+    SDK_MODULE_NOT_FOUND: {
+        code: "SDK_MODULE_NOT_FOUND",
+        name: "SdkModuleNotFoundError",
+        description: "The installed @barekey/sdk module could not be found.",
+    },
+    TYPEGEN_UNSUPPORTED_SDK: {
+        code: "TYPEGEN_UNSUPPORTED_SDK",
+        name: "TypegenUnsupportedSdkError",
+        description: "The installed @barekey/sdk module does not support in-module typegen.",
+    },
+    TYPEGEN_READ_FAILED: {
+        code: "TYPEGEN_READ_FAILED",
+        name: "TypegenReadFailedError",
+        description: "Barekey could not read the generated SDK types.",
+    },
+    TYPEGEN_WRITE_FAILED: {
+        code: "TYPEGEN_WRITE_FAILED",
+        name: "TypegenWriteFailedError",
+        description: "Barekey could not write the generated SDK types.",
+    },
+    UNAUTHORIZED: {
+        code: "UNAUTHORIZED",
+        name: "UnauthorizedError",
+        description: "The provided Barekey credentials were rejected.",
+    },
+    INVALID_ORG_SCOPE: {
+        code: "INVALID_ORG_SCOPE",
+        name: "InvalidOrgScopeError",
+        description: "The requested organization scope is invalid.",
+    },
+    ORG_SCOPE_INVALID: {
+        code: "ORG_SCOPE_INVALID",
+        name: "OrgScopeInvalidError",
+        description: "The authenticated organization scope is invalid.",
+    },
+    INVALID_JSON: {
+        code: "INVALID_JSON",
+        name: "InvalidJsonError",
+        description: "The Barekey request body was invalid JSON.",
+    },
+    INVALID_REQUEST: {
+        code: "INVALID_REQUEST",
+        name: "InvalidRequestError",
+        description: "The Barekey request was invalid.",
+    },
+    VARIABLE_NOT_FOUND: {
+        code: "VARIABLE_NOT_FOUND",
+        name: "VariableNotFoundError",
+        description: "The requested Barekey variable was not found.",
+    },
+    EVALUATION_FAILED: {
+        code: "EVALUATION_FAILED",
+        name: "EvaluationFailedError",
+        description: "Barekey could not evaluate the requested variable.",
+    },
+    USAGE_LIMIT_EXCEEDED: {
+        code: "USAGE_LIMIT_EXCEEDED",
+        name: "UsageLimitExceededError",
+        description: "The Barekey usage limit has been exceeded.",
+    },
+    BILLING_UNAVAILABLE: {
+        code: "BILLING_UNAVAILABLE",
+        name: "BillingUnavailableError",
+        description: "Barekey billing is temporarily unavailable.",
+    },
+    DEVICE_CODE_NOT_FOUND: {
+        code: "DEVICE_CODE_NOT_FOUND",
+        name: "DeviceCodeNotFoundError",
+        description: "The Barekey device code was not found.",
+    },
+    DEVICE_CODE_EXPIRED: {
+        code: "DEVICE_CODE_EXPIRED",
+        name: "DeviceCodeExpiredError",
+        description: "The Barekey device code has expired.",
+    },
+    USER_CODE_INVALID: {
+        code: "USER_CODE_INVALID",
+        name: "UserCodeInvalidError",
+        description: "The Barekey user code is invalid.",
+    },
+    INVALID_REFRESH_TOKEN: {
+        code: "INVALID_REFRESH_TOKEN",
+        name: "InvalidRefreshTokenError",
+        description: "The Barekey refresh token is invalid.",
+    },
+    UNKNOWN_ERROR: {
+        code: "UNKNOWN_ERROR",
+        name: "UnknownError",
+        description: "An unknown Barekey error occurred.",
+    },
+};
+function toDocsSlug(code) {
+    return code.toLowerCase().replaceAll("_", "-");
+}
+export function docsUrlForErrorCode(code) {
+    return `https://docs.barekey.dev/errors/${toDocsSlug(code)}`;
+}
+export function formatBarekeyErrorMessage(code, description) {
+    return `[${code}]: ${description}\n${docsUrlForErrorCode(code)}`;
+}
+export class BarekeyError extends Error {
+    code;
+    docsUrl;
+    requestId;
+    status;
+    cause;
+    constructor(input) {
+        super(formatBarekeyErrorMessage(input.code, input.message));
+        this.name = input.name;
+        this.code = input.code;
+        this.docsUrl = docsUrlForErrorCode(input.code);
+        this.requestId = input.requestId ?? null;
+        this.status = input.status ?? null;
+        this.cause = input.cause;
+    }
+}
+function buildErrorClass(descriptor) {
+    return class extends BarekeyError {
+        constructor(input = {}) {
+            super({
+                code: descriptor.code,
+                name: descriptor.name,
+                message: input.message ?? descriptor.description,
+                requestId: input.requestId,
+                status: input.status,
+                cause: input.cause,
+            });
+        }
+    };
+}
+export const FsNotAvailableError = buildErrorClass(ERROR_DESCRIPTORS.FS_NOT_AVAILABLE);
+export const NoConfigurationProvidedError = buildErrorClass(ERROR_DESCRIPTORS.NO_CONFIGURATION_PROVIDED);
+export const InvalidConfigurationProvidedError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_CONFIGURATION_PROVIDED);
+export const NoCredentialsProvidedError = buildErrorClass(ERROR_DESCRIPTORS.NO_CREDENTIALS_PROVIDED);
+export const InvalidCredentialsProvidedError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_CREDENTIALS_PROVIDED);
+export const InvalidDynamicOptionsError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_DYNAMIC_OPTIONS);
+export const RequirementsValidationFailedError = buildErrorClass(ERROR_DESCRIPTORS.REQUIREMENTS_VALIDATION_FAILED);
+export const NetworkError = buildErrorClass(ERROR_DESCRIPTORS.NETWORK_ERROR);
+export const CoerceFailedError = buildErrorClass(ERROR_DESCRIPTORS.COERCE_FAILED);
+export const TemporalNotAvailableError = buildErrorClass(ERROR_DESCRIPTORS.TEMPORAL_NOT_AVAILABLE);
+export const SdkModuleNotFoundError = buildErrorClass(ERROR_DESCRIPTORS.SDK_MODULE_NOT_FOUND);
+export const TypegenUnsupportedSdkError = buildErrorClass(ERROR_DESCRIPTORS.TYPEGEN_UNSUPPORTED_SDK);
+export const TypegenReadFailedError = buildErrorClass(ERROR_DESCRIPTORS.TYPEGEN_READ_FAILED);
+export const TypegenWriteFailedError = buildErrorClass(ERROR_DESCRIPTORS.TYPEGEN_WRITE_FAILED);
+export const UnauthorizedError = buildErrorClass(ERROR_DESCRIPTORS.UNAUTHORIZED);
+export const InvalidOrgScopeError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_ORG_SCOPE);
+export const OrgScopeInvalidError = buildErrorClass(ERROR_DESCRIPTORS.ORG_SCOPE_INVALID);
+export const InvalidJsonError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_JSON);
+export const InvalidRequestError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_REQUEST);
+export const VariableNotFoundError = buildErrorClass(ERROR_DESCRIPTORS.VARIABLE_NOT_FOUND);
+export const EvaluationFailedError = buildErrorClass(ERROR_DESCRIPTORS.EVALUATION_FAILED);
+export const UsageLimitExceededError = buildErrorClass(ERROR_DESCRIPTORS.USAGE_LIMIT_EXCEEDED);
+export const BillingUnavailableError = buildErrorClass(ERROR_DESCRIPTORS.BILLING_UNAVAILABLE);
+export const DeviceCodeNotFoundError = buildErrorClass(ERROR_DESCRIPTORS.DEVICE_CODE_NOT_FOUND);
+export const DeviceCodeExpiredError = buildErrorClass(ERROR_DESCRIPTORS.DEVICE_CODE_EXPIRED);
+export const UserCodeInvalidError = buildErrorClass(ERROR_DESCRIPTORS.USER_CODE_INVALID);
+export const InvalidRefreshTokenError = buildErrorClass(ERROR_DESCRIPTORS.INVALID_REFRESH_TOKEN);
+export const UnknownError = buildErrorClass(ERROR_DESCRIPTORS.UNKNOWN_ERROR);
+const ERROR_FACTORIES = {
+    FS_NOT_AVAILABLE: (input) => new FsNotAvailableError(input),
+    NO_CONFIGURATION_PROVIDED: (input) => new NoConfigurationProvidedError(input),
+    INVALID_CONFIGURATION_PROVIDED: (input) => new InvalidConfigurationProvidedError(input),
+    NO_CREDENTIALS_PROVIDED: (input) => new NoCredentialsProvidedError(input),
+    INVALID_CREDENTIALS_PROVIDED: (input) => new InvalidCredentialsProvidedError(input),
+    INVALID_DYNAMIC_OPTIONS: (input) => new InvalidDynamicOptionsError(input),
+    REQUIREMENTS_VALIDATION_FAILED: (input) => new RequirementsValidationFailedError(input),
+    NETWORK_ERROR: (input) => new NetworkError(input),
+    COERCE_FAILED: (input) => new CoerceFailedError(input),
+    TEMPORAL_NOT_AVAILABLE: (input) => new TemporalNotAvailableError(input),
+    SDK_MODULE_NOT_FOUND: (input) => new SdkModuleNotFoundError(input),
+    TYPEGEN_UNSUPPORTED_SDK: (input) => new TypegenUnsupportedSdkError(input),
+    TYPEGEN_READ_FAILED: (input) => new TypegenReadFailedError(input),
+    TYPEGEN_WRITE_FAILED: (input) => new TypegenWriteFailedError(input),
+    UNAUTHORIZED: (input) => new UnauthorizedError(input),
+    INVALID_ORG_SCOPE: (input) => new InvalidOrgScopeError(input),
+    ORG_SCOPE_INVALID: (input) => new OrgScopeInvalidError(input),
+    INVALID_JSON: (input) => new InvalidJsonError(input),
+    INVALID_REQUEST: (input) => new InvalidRequestError(input),
+    VARIABLE_NOT_FOUND: (input) => new VariableNotFoundError(input),
+    EVALUATION_FAILED: (input) => new EvaluationFailedError(input),
+    USAGE_LIMIT_EXCEEDED: (input) => new UsageLimitExceededError(input),
+    BILLING_UNAVAILABLE: (input) => new BillingUnavailableError(input),
+    DEVICE_CODE_NOT_FOUND: (input) => new DeviceCodeNotFoundError(input),
+    DEVICE_CODE_EXPIRED: (input) => new DeviceCodeExpiredError(input),
+    USER_CODE_INVALID: (input) => new UserCodeInvalidError(input),
+    INVALID_REFRESH_TOKEN: (input) => new InvalidRefreshTokenError(input),
+    UNKNOWN_ERROR: (input) => new UnknownError(input),
+};
+export function isBarekeyErrorCode(value) {
+    return Object.hasOwn(ERROR_DESCRIPTORS, value);
+}
+export function normalizeErrorCode(value) {
+    const normalized = value.trim().toUpperCase();
+    return isBarekeyErrorCode(normalized) ? normalized : "UNKNOWN_ERROR";
+}
+export function createBarekeyErrorFromCode(input) {
+    const code = normalizeErrorCode(input.code);
+    return ERROR_FACTORIES[code]({
+        message: input.message,
+        requestId: input.requestId,
+        status: input.status,
+        cause: input.cause,
+    });
+}
+export function parseFloatOrThrow(value) {
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to a float.`,
+        });
+    }
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed)) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to a float.`,
+        });
+    }
+    return parsed;
+}
+export function parseBigIntOrThrow(value) {
+    const normalized = value.trim();
+    if (normalized.length === 0 || !/^-?(0|[1-9]\d*)$/.test(normalized)) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to an int64.`,
+        });
+    }
+    let parsed;
+    try {
+        parsed = BigInt(normalized);
+    }
+    catch (error) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to an int64.`,
+            cause: error,
+        });
+    }
+    if (parsed < INT64_MIN || parsed > INT64_MAX) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to an int64.`,
+        });
+    }
+    return parsed;
+}
+export function parseBooleanOrThrow(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes") {
+        return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no") {
+        return false;
+    }
+    throw new CoerceFailedError({
+        message: `Barekey could not coerce "${value}" to a boolean.`,
+    });
+}
+export function parseJsonOrThrow(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new CoerceFailedError({
+            message: "Barekey could not coerce the resolved value to JSON.",
+            cause: error,
+        });
+    }
+}
+export function parseDateOrThrow(value) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to a Date.`,
+        });
+    }
+    return parsed;
+}
+export function parseTemporalInstantOrThrow(value) {
+    const temporalNamespace = globalThis.Temporal;
+    if (!temporalNamespace?.Instant) {
+        throw new TemporalNotAvailableError();
+    }
+    try {
+        return temporalNamespace.Instant.from(value);
+    }
+    catch (error) {
+        throw new CoerceFailedError({
+            message: `Barekey could not coerce "${value}" to a Temporal.Instant.`,
+            cause: error,
+        });
+    }
+}

package/dist/handle.d.ts

@@ -0,0 +1,20 @@
+import type { BarekeyCoerceTarget, BarekeyEvaluatedValue } from "./types.js";
+type BarekeyCoercibleEnvMarker = {
+    readonly __barekey?: {
+        readonly mode: "ab";
+    };
+};
+export declare class BarekeyEnvHandle<TValue = unknown> implements PromiseLike<TValue> {
+    private readonly resolveEvaluatedValue;
+    private readonly transform;
+    private evaluatedValuePromise;
+    constructor(resolveEvaluatedValue: () => Promise<BarekeyEvaluatedValue>, transform?: (resolved: BarekeyEvaluatedValue) => Promise<TValue>);
+    private resolveValue;
+    private getEvaluatedValue;
+    coerce<TCoerced = unknown>(this: [TValue] extends [BarekeyCoercibleEnvMarker] ? BarekeyEnvHandle<TValue> : never, target: BarekeyCoerceTarget): BarekeyEnvHandle<TCoerced>;
+    then<TResult1 = TValue, TResult2 = never>(onfulfilled?: ((value: TValue) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<TValue | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<TValue>;
+}
+export {};
+//# sourceMappingURL=handle.d.ts.map

package/dist/handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../src/handle.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE7E,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;KACrB,CAAC;CACH,CAAC;AAEF,qBAAa,gBAAgB,CAAC,MAAM,GAAG,OAAO,CAAE,YAAW,WAAW,CAAC,MAAM,CAAC;IAC5E,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAuC;IAC7E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuD;IACjF,OAAO,CAAC,qBAAqB,CAA+C;gBAG1E,qBAAqB,EAAE,MAAM,OAAO,CAAC,qBAAqB,CAAC,EAC3D,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,OAAO,CAAC,MAAM,CAAC;YAQpD,YAAY;YAIZ,iBAAiB;IAO/B,MAAM,CAAC,QAAQ,GAAG,OAAO,EACvB,IAAI,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,yBAAyB,CAAC,GAAG,gBAAgB,CAAC,MAAM,CAAC,GAAG,KAAK,EACrF,MAAM,EAAE,mBAAmB,GAC1B,gBAAgB,CAAC,QAAQ,CAAC;IAS7B,IAAI,CAAC,QAAQ,GAAG,MAAM,EAAE,QAAQ,GAAG,KAAK,EACtC,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,EAC1E,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,GAC1E,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAI/B,KAAK,CAAC,OAAO,GAAG,KAAK,EACnB,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,GACxE,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC;IAI5B,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;CAG1D"}

package/dist/handle.js

@@ -0,0 +1,35 @@
+import { coerceEvaluatedValue, parseDeclaredValue, } from "./internal/evaluate.js";
+export class BarekeyEnvHandle {
+    resolveEvaluatedValue;
+    transform;
+    evaluatedValuePromise = null;
+    constructor(resolveEvaluatedValue, transform) {
+        this.resolveEvaluatedValue = resolveEvaluatedValue;
+        this.transform =
+            transform ??
+                (async (resolved) => parseDeclaredValue(resolved.value, resolved.declaredType));
+    }
+    async resolveValue() {
+        return await this.transform(await this.getEvaluatedValue());
+    }
+    async getEvaluatedValue() {
+        if (this.evaluatedValuePromise === null) {
+            this.evaluatedValuePromise = this.resolveEvaluatedValue();
+        }
+        return await this.evaluatedValuePromise;
+    }
+    coerce(target) {
+        return new BarekeyEnvHandle(async () => await this.getEvaluatedValue(), async (resolved) => {
+            return coerceEvaluatedValue(resolved, target);
+        });
+    }
+    then(onfulfilled, onrejected) {
+        return this.resolveValue().then(onfulfilled ?? undefined, onrejected ?? undefined);
+    }
+    catch(onrejected) {
+        return this.resolveValue().catch(onrejected ?? undefined);
+    }
+    finally(onfinally) {
+        return this.resolveValue().finally(onfinally ?? undefined);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { BarekeyClient } from "./client.js";
+export { BarekeyEnvHandle } from "./handle.js";
+export { BarekeyError, BillingUnavailableError, CoerceFailedError, DeviceCodeExpiredError, DeviceCodeNotFoundError, EvaluationFailedError, FsNotAvailableError, InvalidConfigurationProvidedError, InvalidCredentialsProvidedError, InvalidDynamicOptionsError, InvalidJsonError, InvalidOrgScopeError, InvalidRefreshTokenError, InvalidRequestError, NetworkError, NoConfigurationProvidedError, NoCredentialsProvidedError, OrgScopeInvalidError, RequirementsValidationFailedError, SdkModuleNotFoundError, TemporalNotAvailableError, TypegenReadFailedError, TypegenUnsupportedSdkError, TypegenWriteFailedError, UnauthorizedError, UnknownError, UsageLimitExceededError, UserCodeInvalidError, VariableNotFoundError, createBarekeyErrorFromCode, docsUrlForErrorCode, formatBarekeyErrorMessage, isBarekeyErrorCode, normalizeErrorCode, } from "./errors.js";
+export type { AB, BarekeyClientOptions, BarekeyCoerceTarget, BarekeyDeclaredType, BarekeyErrorCode, BarekeyGeneratedTypeMap, BarekeyGetOptions, BarekeyJsonConfig, BarekeyKnownKey, BarekeyResolvedKind, BarekeyRolloutMilestone, BarekeyStandardSchemaV1, BarekeyTemporalInstant, BarekeyTemporalInstantLike, BarekeyTtlInput, BarekeyTypegenResult, Env, Linear, Secret, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,iCAAiC,EACjC,+BAA+B,EAC/B,0BAA0B,EAC1B,gBAAgB,EAChB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,YAAY,EACZ,4BAA4B,EAC5B,0BAA0B,EAC1B,oBAAoB,EACpB,iCAAiC,EACjC,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,0BAA0B,EAC1B,mBAAmB,EACnB,yBAAyB,EACzB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,EAAE,EACF,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,eAAe,EACf,oBAAoB,EACpB,GAAG,EACH,MAAM,EACN,MAAM,GACP,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { BarekeyClient } from "./client.js";
+export { BarekeyEnvHandle } from "./handle.js";
+export { BarekeyError, BillingUnavailableError, CoerceFailedError, DeviceCodeExpiredError, DeviceCodeNotFoundError, EvaluationFailedError, FsNotAvailableError, InvalidConfigurationProvidedError, InvalidCredentialsProvidedError, InvalidDynamicOptionsError, InvalidJsonError, InvalidOrgScopeError, InvalidRefreshTokenError, InvalidRequestError, NetworkError, NoConfigurationProvidedError, NoCredentialsProvidedError, OrgScopeInvalidError, RequirementsValidationFailedError, SdkModuleNotFoundError, TemporalNotAvailableError, TypegenReadFailedError, TypegenUnsupportedSdkError, TypegenWriteFailedError, UnauthorizedError, UnknownError, UsageLimitExceededError, UserCodeInvalidError, VariableNotFoundError, createBarekeyErrorFromCode, docsUrlForErrorCode, formatBarekeyErrorMessage, isBarekeyErrorCode, normalizeErrorCode, } from "./errors.js";

package/dist/internal/cache.d.ts

@@ -0,0 +1,13 @@
+type MemoryCacheRecord<TValue> = {
+    value: TValue;
+    storedAtMs: number;
+    expiresAtMs: number | null;
+};
+export declare class MemoryCache<TValue> {
+    private readonly records;
+    getRecord(key: string): MemoryCacheRecord<TValue> | null;
+    get(key: string): TValue | null;
+    set(key: string, value: TValue, expiresAtMs?: number | null): void;
+}
+export {};
+//# sourceMappingURL=cache.d.ts.map

package/dist/internal/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/internal/cache.ts"],"names":[],"mappings":"AAAA,KAAK,iBAAiB,CAAC,MAAM,IAAI;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,qBAAa,WAAW,CAAC,MAAM;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgD;IAExE,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC,MAAM,CAAC,GAAG,IAAI;IAYxD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAI/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,GAAE,MAAM,GAAG,IAAW,GAAG,IAAI;CAOzE"}

package/dist/internal/cache.js

@@ -0,0 +1,24 @@
+export class MemoryCache {
+    records = new Map();
+    getRecord(key) {
+        const record = this.records.get(key) ?? null;
+        if (record === null) {
+            return null;
+        }
+        if (record.expiresAtMs !== null && record.expiresAtMs <= Date.now()) {
+            this.records.delete(key);
+            return null;
+        }
+        return record;
+    }
+    get(key) {
+        return this.getRecord(key)?.value ?? null;
+    }
+    set(key, value, expiresAtMs = null) {
+        this.records.set(key, {
+            value,
+            storedAtMs: Date.now(),
+            expiresAtMs,
+        });
+    }
+}

package/dist/internal/evaluate.d.ts

@@ -0,0 +1,7 @@
+import type { BarekeyCoerceTarget, BarekeyDeclaredType, BarekeyDecision, BarekeyEvaluatedValue, BarekeyGetOptions, BarekeyVariableDefinition } from "../types.js";
+export declare function validateDynamicOptions(options?: BarekeyGetOptions): void;
+export declare function evaluateDefinition(definition: BarekeyVariableDefinition, options?: Pick<BarekeyGetOptions, "seed" | "key">): Promise<BarekeyEvaluatedValue>;
+export declare function inferSelectedArmFromDecision(decision?: BarekeyDecision): "A" | "B" | undefined;
+export declare function parseDeclaredValue(value: string, declaredType: BarekeyDeclaredType): unknown;
+export declare function coerceEvaluatedValue(resolved: BarekeyEvaluatedValue, target: BarekeyCoerceTarget): unknown;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/internal/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/internal/evaluate.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EAEjB,yBAAyB,EAC1B,MAAM,aAAa,CAAC;AAgDrB,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAKxE;AA4CD,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,yBAAyB,EACrC,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,KAAK,CAAC,GAChD,OAAO,CAAC,qBAAqB,CAAC,CAsDhC;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,CAAC,EAAE,eAAe,GAAG,GAAG,GAAG,GAAG,GAAG,SAAS,CAQ9F;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,mBAAmB,GAAG,OAAO,CAiB5F;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CA0BT"}

package/dist/internal/evaluate.js

@@ -0,0 +1,176 @@
+import { CoerceFailedError, parseBigIntOrThrow, parseBooleanOrThrow, parseDateOrThrow, parseFloatOrThrow, parseJsonOrThrow, } from "../errors.js";
+import { resolveTtlMilliseconds } from "./ttl.js";
+function parseRolloutInstant(value) {
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new CoerceFailedError({
+            message: `Invalid Barekey rollout milestone instant "${value}".`,
+        });
+    }
+    return parsed;
+}
+function normalizeRolloutMilestones(value) {
+    if (value.length === 0) {
+        throw new CoerceFailedError({
+            message: "Rollout milestones must contain at least one entry.",
+        });
+    }
+    let previousAtMs = -Infinity;
+    return value.map((milestone) => {
+        if (!Number.isFinite(milestone.percentage) ||
+            milestone.percentage < 0 ||
+            milestone.percentage > 100) {
+            throw new CoerceFailedError({
+                message: "Rollout milestone percentages must be between 0 and 100.",
+            });
+        }
+        const atMs = parseRolloutInstant(milestone.at);
+        if (atMs <= previousAtMs) {
+            throw new CoerceFailedError({
+                message: "Rollout milestones must be strictly increasing by time.",
+            });
+        }
+        previousAtMs = atMs;
+        return {
+            at: new Date(atMs).toISOString(),
+            percentage: milestone.percentage,
+        };
+    });
+}
+export function validateDynamicOptions(options) {
+    if (options?.dynamic === undefined || options.dynamic === true) {
+        return;
+    }
+    resolveTtlMilliseconds(options.dynamic.ttl, "dynamic.ttl");
+}
+async function deterministicBucket(input) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+    const bytes = new Uint8Array(digest);
+    const value = ((bytes[0] ?? 0) << 24) | ((bytes[1] ?? 0) << 16) | ((bytes[2] ?? 0) << 8) | (bytes[3] ?? 0);
+    return (value >>> 0) / 4294967296;
+}
+function resolveLinearRolloutChance(input) {
+    const milestones = normalizeRolloutMilestones(input.milestones);
+    const first = milestones[0];
+    if (first === undefined) {
+        return 0;
+    }
+    if (input.nowMs < parseRolloutInstant(first.at)) {
+        return 0;
+    }
+    for (let index = 0; index < milestones.length - 1; index += 1) {
+        const current = milestones[index];
+        const next = milestones[index + 1];
+        if (current === undefined || next === undefined) {
+            continue;
+        }
+        const currentAtMs = parseRolloutInstant(current.at);
+        const nextAtMs = parseRolloutInstant(next.at);
+        if (input.nowMs >= currentAtMs && input.nowMs < nextAtMs) {
+            const progress = (input.nowMs - currentAtMs) / (nextAtMs - currentAtMs);
+            const percentage = current.percentage + (next.percentage - current.percentage) * progress;
+            return percentage / 100;
+        }
+    }
+    const last = milestones[milestones.length - 1];
+    return last === undefined ? 0 : last.percentage / 100;
+}
+export async function evaluateDefinition(definition, options) {
+    if (definition.kind === "secret") {
+        return {
+            name: definition.name,
+            kind: definition.kind,
+            declaredType: definition.declaredType,
+            value: definition.value,
+        };
+    }
+    const seed = options?.seed?.trim() ?? "";
+    const key = options?.key?.trim() ?? "";
+    const bucket = seed.length > 0 || key.length > 0
+        ? await deterministicBucket(`${definition.kind}:${definition.name}:${seed}:${key}`)
+        : Math.random();
+    if (definition.kind === "ab_roll") {
+        const selectedArm = bucket < definition.chance ? "A" : "B";
+        return {
+            name: definition.name,
+            kind: definition.kind,
+            declaredType: definition.declaredType,
+            value: selectedArm === "A" ? definition.valueA : definition.valueB,
+            selectedArm,
+            decision: {
+                bucket,
+                chance: definition.chance,
+                seed: seed.length > 0 ? seed : undefined,
+                key: key.length > 0 ? key : undefined,
+                matchedRule: "ab_roll",
+            },
+        };
+    }
+    const chance = resolveLinearRolloutChance({
+        milestones: definition.rolloutMilestones,
+        nowMs: Date.now(),
+    });
+    const selectedArm = bucket < chance ? "B" : "A";
+    return {
+        name: definition.name,
+        kind: definition.kind,
+        declaredType: definition.declaredType,
+        value: selectedArm === "A" ? definition.valueA : definition.valueB,
+        selectedArm,
+        decision: {
+            bucket,
+            chance,
+            seed: seed.length > 0 ? seed : undefined,
+            key: key.length > 0 ? key : undefined,
+            matchedRule: "linear_rollout",
+        },
+    };
+}
+export function inferSelectedArmFromDecision(decision) {
+    if (decision === undefined) {
+        return undefined;
+    }
+    if (decision.matchedRule === "ab_roll") {
+        return decision.bucket < decision.chance ? "A" : "B";
+    }
+    return decision.bucket < decision.chance ? "B" : "A";
+}
+export function parseDeclaredValue(value, declaredType) {
+    if (declaredType === "string") {
+        return value;
+    }
+    if (declaredType === "boolean") {
+        return parseBooleanOrThrow(value);
+    }
+    if (declaredType === "int64") {
+        return parseBigIntOrThrow(value);
+    }
+    if (declaredType === "float") {
+        return parseFloatOrThrow(value);
+    }
+    if (declaredType === "date") {
+        return parseDateOrThrow(value);
+    }
+    return parseJsonOrThrow(value);
+}
+export function coerceEvaluatedValue(resolved, target) {
+    if (target === "string") {
+        return resolved.value;
+    }
+    if (target === "boolean" && resolved.selectedArm !== undefined) {
+        return resolved.selectedArm === "B";
+    }
+    if (target === "boolean") {
+        return parseBooleanOrThrow(resolved.value);
+    }
+    if (target === "int64") {
+        return parseBigIntOrThrow(resolved.value);
+    }
+    if (target === "float") {
+        return parseFloatOrThrow(resolved.value);
+    }
+    if (target === "date") {
+        return parseDateOrThrow(resolved.value);
+    }
+    return parseJsonOrThrow(resolved.value);
+}

package/dist/internal/http.d.ts

@@ -0,0 +1,19 @@
+export type InternalAuthResolver = {
+    getAccessToken(): Promise<string>;
+    onUnauthorized?(): Promise<void>;
+};
+export declare function normalizeBaseUrl(baseUrl: string): string;
+export declare function postJson<TResponse>(input: {
+    fetchFn: typeof globalThis.fetch;
+    baseUrl: string;
+    path: string;
+    payload: unknown;
+    auth?: InternalAuthResolver;
+}): Promise<TResponse>;
+export declare function getJson<TResponse>(input: {
+    fetchFn: typeof globalThis.fetch;
+    baseUrl: string;
+    path: string;
+    auth?: InternalAuthResolver;
+}): Promise<TResponse>;
+//# sourceMappingURL=http.d.ts.map