enhancement(sdk): simplify config and auth handling in the SDK factory

Author: Convly

README.md

@@ -111,7 +111,6 @@ const sdk = strapi({
   // Endpoint configuration
   baseURL: 'http://localhost:1337/api',
   // Auth configuration
-  authStrategy: 'api-token',
   auth: 'your-api-token-here',
 });
 ```
@@ -248,7 +247,6 @@ Below is a list of available namespaces to use:
 | `strapi:auth:factory`                    | Logs the registration and creation of authentication providers.                           |
 | `strapi:auth:manager`                    | Logs authentication lifecycle management.                                                 |
 | `strapi:auth:provider:api-token`         | Logs operations related to API token authentication.                                      |
-| `strapi:auth:provider:users-permissions` | Logs operations related to user and permissions-based authentication.                     |
 | `strapi:ct:collection`                   | Logs interactions with collection-type content managers.                                  |
 | `strapi:ct:single`                       | Logs interactions with single-type content managers.                                      |
 | `strapi:utils:url-helper`                | Logs URL helper utility operations (e.g., appending query parameters or formatting URLs). |

src/index.ts

@@ -1,10 +1,46 @@
+import { ApiTokenAuthProvider } from './auth';
 import { Strapi } from './sdk';
-import { StrapiConfigValidator } from './validators';
 
 import type { StrapiConfig } from './sdk';
 
 export * from './errors';
 
+export interface Config {
+  /**
+   * The base URL of the Strapi content API.
+   *
+   * This specifies where the SDK should send requests.
+   *
+   * The URL must include the protocol (`http` or `https`) and serve
+   * as the root path for all later API operations.
+   *
+   * @example
+   * 'https://api.example.com'
+   *
+   * @remarks
+   * Failing to provide a valid HTTP or HTTPS URL results in a
+   * `StrapiInitializationError`.
+   */
+  baseURL: string;
+
+  /**
+   * API token to authenticate requests (optional).
+   *
+   * When provided, this token is included in the `Authorization` header
+   * of every request to the Strapi API.
+   *
+   * @remarks
+   * - A valid token must be a non-empty string.
+   *
+   * - If the token is invalid or improperly formatted, the SDK
+   * throws a `StrapiValidationError` during initialization.
+   *
+   * - If excluded, the SDK operates without authentication.
+   */
+
+  auth?: string;
+}
+
 /**
  * Creates a new instance of the Strapi SDK with a specified configuration.
  *
@@ -25,8 +61,7 @@ export * from './errors';
  * // Basic configuration using API token auth
  * const config = {
  *   baseURL: 'https://api.example.com',
- *   authStrategy: 'api-token',
- *   auth: 'you_token_here',
+ *   auth: 'your_token_here',
  * };
  *
  * // Create the SDK instance
@@ -42,13 +77,14 @@ export * from './errors';
  * @throws {StrapiInitializationError} If the provided baseURL doesn't conform to a valid HTTP or HTTPS URL,
  *                                        or if the auth configuration is invalid.
  */
-export const strapi = (config: StrapiConfig) => {
-  const configValidator = new StrapiConfigValidator();
-
-  return new Strapi<typeof config>(
-    // Properties
-    config,
-    // Dependencies
-    configValidator
-  );
+export const strapi = (config: Config) => {
+  const customConfig: StrapiConfig = { ...config };
+
+  // In this factory, users can't set an authStrategy manually to keep things simple.
+  // Since the SDK constructor needs an authStrategy if an auth property is provided, it is set to API token by default
+  if (customConfig.auth !== undefined) {
+    customConfig.authStrategy = ApiTokenAuthProvider.identifier;
+  }
+
+  return new Strapi(customConfig);
 };

src/sdk.ts

@@ -30,12 +30,10 @@ export interface StrapiConfig {
  *
  * It serves as the main interface through which users interact with
  * their Strapi installation programmatically.
- *
- * @template T_Config - Configuration type inferred from the user-provided SDK configuration
  */
-export class Strapi<const T_Config extends StrapiConfig = StrapiConfig> {
+export class Strapi {
   /** @internal */
-  private readonly _config: T_Config;
+  private readonly _config: StrapiConfig;
 
   /** @internal */
   private readonly _validator: StrapiConfigValidator;
@@ -49,7 +47,7 @@ export class Strapi<const T_Config extends StrapiConfig = StrapiConfig> {
   /** @internal */
   constructor(
     // Properties
-    config: T_Config,
+    config: StrapiConfig,
 
     // Dependencies
     validator: StrapiConfigValidator = new StrapiConfigValidator(),

tests/unit/index.test.ts

@@ -1,12 +1,12 @@
 import { strapi, StrapiInitializationError } from '../../src';
 import { Strapi } from '../../src/sdk';
 
-import type { StrapiConfig } from '../../src/sdk';
+import type { Config } from '../../src';
 
 describe('strapi', () => {
-  it('should create an SDK instance with valid configuration', () => {
+  it('should create an SDK instance with valid http configuration', () => {
     // Arrange
-    const config = { baseURL: 'https://api.example.com' } satisfies StrapiConfig;
+    const config = { baseURL: 'https://api.example.com' } satisfies Config;
 
     // Act
     const sdk = strapi(config);
@@ -16,9 +16,20 @@ describe('strapi', () => {
     expect(sdk).toHaveProperty('baseURL', config.baseURL);
   });
 
+  it('should create an SDK instance with valid auth configuration', () => {
+    // Arrange
+    const config = { baseURL: 'https://api.example.com', auth: '<token>' } satisfies Config;
+
+    // Act
+    const sdk = strapi(config);
+
+    // Assert
+    expect(sdk).toBeInstanceOf(Strapi);
+  });
+
   it('should throw an error for an invalid baseURL', () => {
     // Arrange
-    const config = { baseURL: 'invalid-url' } satisfies StrapiConfig;
+    const config = { baseURL: 'invalid-url' } satisfies Config;
 
     // Act & Assert
     expect(() => strapi(config)).toThrow(StrapiInitializationError);
@@ -28,9 +39,8 @@ describe('strapi', () => {
     // Arrange
     const config = {
       baseURL: 'https://api.example.com',
-      authStrategy: 'api-token',
-      auth: '', // Invalid token
-    } satisfies StrapiConfig;
+      auth: '', // Invalid API token
+    } satisfies Config;
 
     // Act & Assert
     expect(() => strapi(config)).toThrow(StrapiInitializationError);