@adobe/aio-commerce-lib-auth 0.2.0 → 0.3.0

package/source/lib/ims-auth/schema.ts

@@ -1,87 +0,0 @@
-/*
- * Copyright 2025 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-import {
-  type InferOutput,
-  nonEmpty,
-  object,
-  optional,
-  parseJson,
-  pipe,
-  string,
-  array as vArray,
-  enum as vEnum,
-  message as vMessage,
-} from "valibot";
-
-const imsAuthParameter = (name: string) =>
-  pipe(
-    string(`Expected a string value for the IMS auth parameter ${name}`),
-    nonEmpty(
-      `Expected a non-empty string value for the IMS auth parameter ${name}`,
-    ),
-  );
-
-const jsonStringArray = (name: string) => {
-  const jsonStringArraySchema = vMessage(
-    pipe(
-      string(`Expected a string value for the IMS auth parameter ${name}`),
-      nonEmpty(
-        `Expected a non-empty string value for the IMS auth parameter ${name}`,
-      ),
-      parseJson(),
-    ),
-    `An error occurred while parsing the JSON string array parameter ${name}`,
-  );
-
-  return pipe(
-    jsonStringArraySchema,
-    vArray(
-      string(),
-      `Expected a stringified JSON array value for the IMS auth parameter ${name}`,
-    ),
-  );
-};
-
-/** The environments accepted by the IMS auth service. */
-export const IMS_AUTH_ENV = {
-  PROD: "prod",
-  STAGE: "stage",
-} as const;
-
-const ImsAuthEnvSchema = vEnum(IMS_AUTH_ENV);
-
-/** Defines the schema to validate the necessary parameters for the IMS auth service. */
-export const ImsAuthParamsSchema = object({
-  AIO_COMMERCE_IMS_CLIENT_ID: imsAuthParameter("AIO_COMMERCE_IMS_CLIENT_ID"),
-  AIO_COMMERCE_IMS_CLIENT_SECRETS: jsonStringArray(
-    "AIO_COMMERCE_IMS_CLIENT_SECRETS",
-  ),
-  AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID: imsAuthParameter(
-    "AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID",
-  ),
-
-  AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL: imsAuthParameter(
-    "AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL",
-  ),
-  AIO_COMMERCE_IMS_IMS_ORG_ID: imsAuthParameter("AIO_COMMERCE_IMS_IMS_ORG_ID"),
-
-  AIO_COMMERCE_IMS_ENV: pipe(optional(ImsAuthEnvSchema, IMS_AUTH_ENV.PROD)),
-  AIO_COMMERCE_IMS_CTX: pipe(optional(string(), "aio-commerce-sdk-creds")),
-  AIO_COMMERCE_IMS_SCOPES: jsonStringArray("AIO_COMMERCE_IMS_SCOPES"),
-});
-
-/** Defines the parameters for the IMS auth service. */
-export type ImsAuthParams = InferOutput<typeof ImsAuthParamsSchema>;
-
-/** Defines the environments accepted by the IMS auth service. */
-export type ImsAuthEnv = InferOutput<typeof ImsAuthEnvSchema>;

package/source/lib/integration-auth/provider.ts

@@ -1,145 +0,0 @@
-/*
- * Copyright 2025 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-import crypto from "node:crypto";
-
-import { err, ok, type Result } from "@adobe/aio-commerce-lib-core/result";
-import type { ValidationErrorType } from "@adobe/aio-commerce-lib-core/validation";
-
-import OAuth1a from "oauth-1.0a";
-import { type InferIssue, safeParse } from "valibot";
-
-import {
-  type AdobeCommerceUri,
-  type HttpMethodInput,
-  type IntegrationAuthParams,
-  IntegrationAuthParamsSchema,
-  UrlSchema,
-} from "./schema";
-
-type IntegrationAuthHeader = "Authorization";
-type IntegrationAuthHeaders = Record<IntegrationAuthHeader, string>;
-
-/** Defines the configuration to create an {@link IntegrationAuthProvider}. */
-export interface IntegrationConfig {
-  consumerKey: string;
-  consumerSecret: string;
-  accessToken: string;
-  accessTokenSecret: string;
-}
-
-type ValidationIssues =
-  | InferIssue<typeof IntegrationAuthParamsSchema>[]
-  | InferIssue<typeof UrlSchema>[];
-
-/** Defines an error type for the integration auth service. */
-export type IntegrationAuthError = ValidationErrorType<
-  "IntegrationAuthValidationError",
-  ValidationIssues
->;
-
-/** Defines an authentication provider for Adobe Commerce integrations. */
-export interface IntegrationAuthProvider {
-  getHeaders: (
-    method: HttpMethodInput,
-    url: AdobeCommerceUri,
-  ) => Result<IntegrationAuthHeaders, IntegrationAuthError>;
-}
-
-function makeIntegrationAuthValidationError(
-  message: string,
-  issues: ValidationIssues,
-) {
-  return {
-    _tag: "IntegrationAuthValidationError",
-    message,
-    issues,
-  } satisfies IntegrationAuthError;
-}
-
-function fromParams(params: IntegrationAuthParams) {
-  return {
-    consumerKey: params.AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY,
-    consumerSecret: params.AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET,
-    accessToken: params.AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN,
-    accessTokenSecret: params.AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET,
-  } satisfies IntegrationConfig;
-}
-
-/**
- * Creates an {@link IntegrationAuthProvider} based on the provided configuration.
- * @param config The configuration for the integration.
- * @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
- */
-export function getIntegrationAuthProvider(
-  config: IntegrationConfig,
-): IntegrationAuthProvider {
-  const oauth = new OAuth1a({
-    consumer: {
-      key: config.consumerKey,
-      secret: config.consumerSecret,
-    },
-    signature_method: "HMAC-SHA256",
-    hash_function: (baseString, key) =>
-      crypto.createHmac("sha256", key).update(baseString).digest("base64"),
-  });
-
-  const oauthToken = {
-    key: config.accessToken,
-    secret: config.accessTokenSecret,
-  };
-
-  const getHeaders = (method: HttpMethodInput, url: AdobeCommerceUri) => {
-    const uriValidation = safeParse(UrlSchema, url);
-    if (!uriValidation.success) {
-      return err(
-        makeIntegrationAuthValidationError(
-          "Failed to validate the provided Adobe Commerce URL",
-          uriValidation.issues,
-        ),
-      );
-    }
-
-    const finalUrl = uriValidation.output;
-    const headers = oauth.toHeader(
-      oauth.authorize({ url: finalUrl, method }, oauthToken),
-    );
-
-    return ok(headers);
-  };
-
-  return {
-    getHeaders,
-  };
-}
-
-/**
- * Tries to create an {@link IntegrationAuthProvider} based on the provided parameters.
- * @param params The parameters required for integration authentication.
- * @returns An {@link IntegrationAuthProvider} instance that can be used to get auth headers.
- */
-export function tryGetIntegrationAuthProvider(
-  params: IntegrationAuthParams,
-): Result<IntegrationAuthProvider, IntegrationAuthError> {
-  const validation = safeParse(IntegrationAuthParamsSchema, params);
-
-  if (!validation.success) {
-    return err(
-      makeIntegrationAuthValidationError(
-        "Failed to validate the provided integration parameters",
-        validation.issues,
-      ),
-    );
-  }
-
-  return ok(getIntegrationAuthProvider(fromParams(validation.output)));
-}

package/source/lib/integration-auth/schema.ts

@@ -1,87 +0,0 @@
-/*
- * Copyright 2025 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-import {
-  type InferInput,
-  instance,
-  nonEmpty,
-  nonOptional,
-  object,
-  picklist,
-  pipe,
-  string,
-  transform,
-  union,
-  url as vUrl,
-} from "valibot";
-
-/**
- * The HTTP methods supported by Commerce.
- * This is used to determine which headers to include in the signing of the authorization header.
- */
-const AllowedHttpMethod = ["GET", "POST", "PUT", "PATCH", "DELETE"] as const;
-
-export const HttpMethodSchema = picklist(AllowedHttpMethod);
-export type HttpMethodInput = InferInput<typeof HttpMethodSchema>;
-
-const integrationAuthParameter = (name: string) =>
-  pipe(
-    string(
-      `Expected a string value for the Commerce Integration parameter ${name}`,
-    ),
-    nonEmpty(
-      `Expected a non-empty string value for the Commerce Integration parameter ${name}`,
-    ),
-  );
-
-const BaseUrlSchema = pipe(
-  string("Expected a string for the Adobe Commerce endpoint"),
-  nonEmpty("Expected a non-empty string for the Adobe Commerce endpoint"),
-  vUrl("Expected a valid url for the Adobe Commerce endpoint"),
-);
-
-export const UrlSchema = pipe(
-  union([BaseUrlSchema, instance(URL)]),
-  transform((url) => {
-    if (url instanceof URL) {
-      return url.toString();
-    }
-    return url;
-  }),
-);
-
-export type AdobeCommerceUri = InferInput<typeof UrlSchema>;
-
-/**
- * The schema for the Commerce Integration parameters.
- * This is used to validate the parameters passed to the Commerce Integration provider.
- */
-export const IntegrationAuthParamsSchema = nonOptional(
-  object({
-    AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY: integrationAuthParameter(
-      "AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY",
-    ),
-    AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET: integrationAuthParameter(
-      "AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET",
-    ),
-    AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN: integrationAuthParameter(
-      "AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN",
-    ),
-    AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET: integrationAuthParameter(
-      "AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET",
-    ),
-  }),
-);
-
-export type IntegrationAuthParams = InferInput<
-  typeof IntegrationAuthParamsSchema
->;

package/test/ims-auth.test.ts

@@ -1,147 +0,0 @@
-/*
- * Copyright 2025 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-import { unwrap, unwrapErr } from "@adobe/aio-commerce-lib-core/result";
-import { getToken } from "@adobe/aio-lib-ims";
-
-import type { InferInput } from "valibot";
-import { describe, expect, test, vi } from "vitest";
-
-import {
-  getImsAuthProvider,
-  tryGetImsAuthProvider,
-} from "~/lib/ims-auth/provider";
-
-import { IMS_AUTH_ENV, type ImsAuthParamsSchema } from "~/lib/ims-auth/schema";
-
-vi.mock("@adobe/aio-lib-ims", async () => ({
-  context: (await vi.importActual("@adobe/aio-lib-ims")).context,
-  getToken: vi.fn(),
-}));
-
-describe("IMS Authentication", () => {
-  describe("getImsAuthProvider", () => {
-    test("should export token", async () => {
-      const authToken = "supersecrettoken";
-      vi.mocked(getToken).mockResolvedValue(authToken);
-
-      const config = {
-        clientId: "test-client-id",
-        clientSecrets: ["supersecret"],
-        technicalAccountId: "test-technical-account-id",
-        technicalAccountEmail: "test-email@example.com",
-        imsOrgId: "test-org-id",
-        scopes: ["scope1", "scope2"],
-        environment: IMS_AUTH_ENV.PROD,
-        context: "test-context",
-      };
-
-      const imsAuthProvider = getImsAuthProvider(config);
-      expect(imsAuthProvider).toBeDefined();
-
-      const retrievedToken = await imsAuthProvider.getAccessToken();
-      expect(unwrap(retrievedToken)).toEqual(authToken);
-
-      const headers = unwrap(await imsAuthProvider.getHeaders());
-      expect(headers).toHaveProperty("Authorization", `Bearer ${authToken}`);
-      expect(headers).toHaveProperty("x-api-key", config.clientId);
-    });
-  });
-
-  describe("tryGetImsAuthProvider", () => {
-    const params = {
-      AIO_COMMERCE_IMS_CLIENT_ID: "test-client-id",
-      AIO_COMMERCE_IMS_CLIENT_SECRETS: JSON.stringify(["supersecret"]),
-      AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID: "test-technical-account-id",
-      AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL: "test-email@example.com",
-      AIO_COMMERCE_IMS_IMS_ORG_ID: "test-org-id",
-      AIO_COMMERCE_IMS_SCOPES: JSON.stringify(["scope1", "scope2"]),
-    } satisfies InferInput<typeof ImsAuthParamsSchema>;
-
-    test("should export token when all required params are provided", async () => {
-      const authToken = "supersecrettoken";
-      vi.mocked(getToken).mockResolvedValue(authToken);
-
-      const imsAuthProvider = unwrap(tryGetImsAuthProvider(params));
-      const retrievedToken = unwrap(await imsAuthProvider.getAccessToken());
-      expect(retrievedToken).toEqual(authToken);
-
-      const headers = unwrap(await imsAuthProvider.getHeaders());
-      expect(headers).toHaveProperty("Authorization", `Bearer ${authToken}`);
-      expect(headers).toHaveProperty(
-        "x-api-key",
-        params.AIO_COMMERCE_IMS_CLIENT_ID,
-      );
-    });
-
-    test("should err with invalid params", () => {
-      const result = unwrapErr(
-        tryGetImsAuthProvider(
-          {} as unknown as InferInput<typeof ImsAuthParamsSchema>,
-        ),
-      );
-
-      expect(result).toHaveProperty("_tag", "ImsAuthValidationError");
-      expect(result).toHaveProperty("issues", expect.any(Array));
-    });
-
-    test.each([
-      "AIO_COMMERCE_IMS_CLIENT_ID",
-      "AIO_COMMERCE_IMS_CLIENT_SECRETS",
-      "AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_ID",
-      "AIO_COMMERCE_IMS_TECHNICAL_ACCOUNT_EMAIL",
-      "AIO_COMMERCE_IMS_IMS_ORG_ID",
-      "AIO_COMMERCE_IMS_SCOPES",
-    ])("should throw error when %s is missing", (param) => {
-      const result = tryGetImsAuthProvider({
-        ...params,
-        [param]: undefined,
-      } satisfies InferInput<typeof ImsAuthParamsSchema>);
-
-      expect(() => unwrap(result)).toThrow();
-
-      const error = unwrapErr(result);
-      expect(error._tag).toEqual("ImsAuthValidationError");
-      expect(error.message).toEqual(
-        "Failed to validate the provided IMS parameters",
-      );
-
-      expect(error.issues).toHaveLength(1);
-      expect(error.issues[0].message).toEqual(
-        `Expected a string value for the IMS auth parameter ${param}`,
-      );
-    });
-
-    test.each([
-      ["[test, foo]", "AIO_COMMERCE_IMS_SCOPES"],
-      ['[{test: "foo"}]', "AIO_COMMERCE_IMS_SCOPES"],
-      ['["test"', "AIO_COMMERCE_IMS_SCOPES"],
-      ["[test, foo]", "AIO_COMMERCE_IMS_CLIENT_SECRETS"],
-      ['[{test: "foo"}]', "AIO_COMMERCE_IMS_CLIENT_SECRETS"],
-      ['["test"', "AIO_COMMERCE_IMS_CLIENT_SECRETS"],
-    ])(`should throw error when given %s as %s input"`, (param, key) => {
-      const result = tryGetImsAuthProvider({
-        ...params,
-        [key]: param,
-      } satisfies InferInput<typeof ImsAuthParamsSchema>);
-
-      expect(() => unwrap(result)).toThrow();
-
-      const error = unwrapErr(result);
-      expect(error._tag).toEqual("ImsAuthValidationError");
-      expect(error.issues).toHaveLength(1);
-      expect(error.issues[0].message).toEqual(
-        `An error occurred while parsing the JSON string array parameter ${key}`,
-      );
-    });
-  });
-});

package/test/integration-auth.test.ts

@@ -1,124 +0,0 @@
-/*
- * Copyright 2025 Adobe. All rights reserved.
- * This file is licensed to you under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License. You may obtain a copy
- * of the License at http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
- * OF ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- */
-
-import { unwrap, unwrapErr } from "@adobe/aio-commerce-lib-core/result";
-import type { InferInput } from "valibot";
-
-import { describe, expect, test } from "vitest";
-import {
-  getIntegrationAuthProvider,
-  tryGetIntegrationAuthProvider,
-} from "~/lib/integration-auth/provider";
-
-import type {
-  IntegrationAuthParams,
-  IntegrationAuthParamsSchema,
-} from "~/lib/integration-auth/schema";
-
-/** Regex to match the OAuth 1.0a header format. */
-const OAUTH1_REGEX =
-  /^OAuth oauth_consumer_key="[^"]+", oauth_nonce="[^"]+", oauth_signature="[^"]+", oauth_signature_method="HMAC-SHA256", oauth_timestamp="[^"]+", oauth_token="[^"]+", oauth_version="1\.0"$/;
-
-describe("Commerce Integration Auth", () => {
-  describe("getIntegrationAuthProvider", () => {
-    test("should export getIntegrationAuthProvider", () => {
-      const integrationAuthProvider = getIntegrationAuthProvider({
-        consumerKey: "test-consumer-key",
-        consumerSecret: "test-consumer-secret",
-        accessToken: "test-access-token",
-        accessTokenSecret: "test-access-token-secret",
-      });
-
-      const headers = unwrap(
-        integrationAuthProvider.getHeaders("GET", "http://localhost/test"),
-      );
-
-      expect(headers).toHaveProperty(
-        "Authorization",
-        expect.stringMatching(OAUTH1_REGEX),
-      );
-    });
-  });
-
-  describe("tryGetIntegrationAuthProvider", () => {
-    const params: IntegrationAuthParams = {
-      AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY: "test-consumer-key",
-      AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET: "test-consumer-secret",
-      AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN: "test-access-token",
-      AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET: "test-access-token-secret",
-    };
-
-    test("should export getIntegrationAccessToken", () => {
-      const result = unwrap(tryGetIntegrationAuthProvider(params));
-      const headers = unwrap(result.getHeaders("GET", "http://localhost/test"));
-
-      expect(headers).toHaveProperty(
-        "Authorization",
-        expect.stringMatching(OAUTH1_REGEX),
-      );
-    });
-
-    test("should err with invalid params", () => {
-      const result = unwrapErr(
-        tryGetIntegrationAuthProvider({} as unknown as IntegrationAuthParams),
-      );
-
-      expect(result).toHaveProperty("_tag", "IntegrationAuthValidationError");
-      expect(result).toHaveProperty("issues", expect.any(Array));
-    });
-
-    test.each([
-      "AIO_COMMERCE_INTEGRATIONS_CONSUMER_KEY",
-      "AIO_COMMERCE_INTEGRATIONS_CONSUMER_SECRET",
-      "AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN",
-      "AIO_COMMERCE_INTEGRATIONS_ACCESS_TOKEN_SECRET",
-    ])("should throw error when %s is missing", (param) => {
-      const result = tryGetIntegrationAuthProvider({
-        ...params,
-        [param]: undefined,
-      } satisfies InferInput<typeof IntegrationAuthParamsSchema>);
-
-      expect(() => unwrap(result)).toThrow();
-
-      const error = unwrapErr(result);
-      expect(error._tag).toEqual("IntegrationAuthValidationError");
-      expect(error.message).toEqual(
-        "Failed to validate the provided integration parameters",
-      );
-
-      expect(error.issues).toHaveLength(1);
-      expect(error.issues[0].message).toEqual(
-        `Expected a string value for the Commerce Integration parameter ${param}`,
-      );
-    });
-
-    test.each([
-      ["localhost"],
-      ["http:://"],
-      ["https://"],
-      ["//example.com"],
-      ["http://user@:80"],
-    ])("should throw an Error on invalid [%s] URL", (url) => {
-      const integrationAuthProvider = unwrap(
-        tryGetIntegrationAuthProvider(params),
-      );
-
-      const getHeadersResult = integrationAuthProvider.getHeaders("GET", url);
-      const error = unwrapErr(getHeadersResult);
-
-      expect(error._tag).toEqual("IntegrationAuthValidationError");
-      expect(error.message).toEqual(
-        "Failed to validate the provided Adobe Commerce URL",
-      );
-    });
-  });
-});

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "@aio-commerce-sdk/config-typescript/tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "rootDir": ".",
-    "outDir": "./dist",
-
-    "paths": {
-      "~/*": ["./source/*"],
-      "~~/*": ["./*"]
-    }
-  },
-
-  "include": ["tsdown.config.ts", "source/**/*", "test/**/*"]
-}

package/tsdown.config.ts

@@ -1,7 +0,0 @@
-import { baseConfig } from "@aio-commerce-sdk/config-tsdown/tsdown.config.base";
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  ...baseConfig,
-  entry: ["./source/index.ts"],
-});

package/vitest.config.ts

@@ -1,16 +0,0 @@
-import { resolve } from "node:path";
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  resolve: {
-    alias: {
-      "~": resolve(__dirname, "./source"),
-      "~~": resolve(__dirname, "./"),
-    },
-  },
-
-  test: {
-    globals: true,
-    environment: "node",
-  },
-});