feat: initialization

.commitlintrc.ts

@@ -1,6 +1,7 @@
-import type { UserConfig } from '@commitlint/types';
 import { RuleConfigSeverity } from '@commitlint/types';
 
+import type { UserConfig } from '@commitlint/types';
+
 const config: UserConfig = {
   extends: ['@commitlint/config-conventional'],
   rules: {

.gitignore

@@ -42,6 +42,7 @@ $RECYCLE.BIN/
 *.jar
 *.rar
 *.tar
+*.tgz
 *.zip
 *.com
 *.class

.prettierignore

@@ -1,2 +1,3 @@
 bin
 dist
+.github

README.md

@@ -1,5 +1,5 @@
 <h1 align="center">sdk-js</h1>
-<h3 align="center">An SDK you can use to easily interface with Strapi from your javascript project</h3>
+<h3 align="center">An SDK you can use to easily interface with Strapi from your JavaScript and TypeScript projects</h3>
 
 <br />
 
@@ -21,13 +21,14 @@ sdk-js is an SDK you can use to easily interface with Strapi from your JavaScrip
 
 ## Getting Started With Strapi
 
-If you're brand new to Strapi development, we recommend you follow the [Strapi Quick Start Guide](https://docs.strapi.io/dev-docs/quick-start)
+If you're brand new to Strapi development, it is recommended to follow the [Strapi Quick Start Guide](https://docs.strapi.io/dev-docs/quick-start)
 
 sdk-js is compatible with Strapi v5+ and interfaces with Strapi's REST API. You can read the API docs [here](https://docs.strapi.io/dev-docs/api/rest)
 
 ## SDK Purpose
 
-sdk-js is the recommended and easiest way to interface with Strapi from your javascript project. It allows you to easily create, read, update, and delete Strapi content through strongly typed methods.
+sdk-js is the recommended and easiest way to interface with Strapi from your JavaScript and TypeScript projects.
+It allows you to easily create, read, update, and delete Strapi content through strongly typed methods.
 
 <!-- TODO confirm whether this is done in MVP -->
 
@@ -42,11 +43,11 @@ In its simplest form, "@strapi/sdk-js" works by being connected to the URL of yo
 ### Importing the SDK
 
 ```js
-import { createSDK } from '@strapi/sdk-js'; // ES Modules
-// const { createSDK } = require("@strapi/sdk-js"); CommonJS
+import { createStrapiSDK } from '@strapi/sdk-js'; // ES Modules
+// const { createStrapiSDK } = require("@strapi/sdk-js"); CommonJS
 
-const strapiSDK = createSDK({
-  url: 'http://localhost:1337',
+const strapiSDK = createStrapiSDK({
+  baseURL: 'http://localhost:1337',
 });
 ```
 
@@ -55,8 +56,8 @@ const strapiSDK = createSDK({
 ```html
 <script src="https://cdn.jsdelivr.net/npm/@strapi/sdk-js"></script>
 <script>
-  const strapiSDK = createSDK({
-    url: 'http://localhost:1337',
+  const strapiSDK = createStrapiSDK({
+    baseURL: 'http://localhost:1337',
   });
 </script>
 ```
@@ -89,12 +90,12 @@ As opposed to importing the SDK from a CDN or NPM, the generated asset can then
 Alternatively, you can use the SDK from a CDN or NPM, but provide the SDK with a Strapi schema.
 
 ```js
-import { createSDK } from '@strapi/sdk-js';
+import { createStrapiSDK } from '@strapi/sdk-js';
 // TODO clarify where this comes from and how to generate it
 import strapiAppSchema from '../path/to/strapi-app-schema.json';
 
-const strapiSDK = createSDK({
-  url: 'http://localhost:1337',
+const strapiSDK = createStrapiSDK({
+  baseURL: 'http://localhost:1337',
   schema: strapiAppSchema,
 });
 ```

eslint.config.mjs

@@ -0,0 +1,49 @@
+import pluginEslintImport from 'eslint-plugin-import';
+import pluginTypescriptEslint from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+
+export default {
+  languageOptions: {
+    parser: tsParser,
+    parserOptions: {
+      project: ['./tsconfig.eslint.json'],
+    },
+  },
+  files: ['{src,tests}/**/*.{js,ts,jsx,tsx,yml,yaml}'],
+  plugins: {
+    '@typescript-eslint': pluginTypescriptEslint,
+    import: pluginEslintImport,
+  },
+  rules: {
+    // Use the TypeScript port of 'no-unused-vars' to prevent false positives on abstract methods parameters
+    // while keeping consistency with TS native behavior of ignoring parameters starting with '_'.
+    // https://typescript-eslint.io/rules/no-unused-vars/
+    'no-unused-vars': 'off',
+    '@typescript-eslint/no-unused-vars': [
+      'error',
+      {
+        args: 'all',
+        argsIgnorePattern: '^_',
+        caughtErrors: 'all',
+        caughtErrorsIgnorePattern: '^_',
+        destructuredArrayIgnorePattern: '^_',
+        varsIgnorePattern: '^_',
+        ignoreRestSiblings: true,
+      },
+    ],
+
+    // eslint-plugin-import
+    'import/no-default-export': 'error',
+    'import/consistent-type-specifier-style': ['error', 'prefer-top-level'],
+    'import/first': ['error'],
+    'import/exports-last': ['error'],
+    'import/order': [
+      'error',
+      {
+        groups: ['builtin', 'external', 'internal', 'parent', 'sibling', 'index', 'object', 'type'],
+        'newlines-between': 'always',
+        alphabetize: { order: 'asc', caseInsensitive: true },
+      },
+    ],
+  },
+};

jest.config.js

@@ -1,9 +1,19 @@
 /** @type {import('ts-jest').JestConfigWithTsJest} **/
 module.exports = {
+  rootDir: '.',
   testEnvironment: 'node',
   testMatch: ['<rootDir>/tests/unit/**/*.test.ts'],
   transform: {
     '^.+.tsx?$': ['ts-jest', {}],
   },
   coverageDirectory: '<rootDir>/.coverage/',
+  coveragePathIgnorePatterns: ['/node_modules/', '/tests/'],
+  coverageThreshold: {
+    global: {
+      branches: 95,
+      functions: 95,
+      lines: 95,
+      statements: 95,
+    },
+  },
 };

package.json

@@ -32,7 +32,10 @@
     },
     "./package.json": "./package.json"
   },
-  "files": [],
+  "files": [
+    "./package.json",
+    "dist/"
+  ],
   "scripts": {
     "build": "rollup --config rollup.config.mjs --failAfterWarnings",
     "build:clean": "rollup --config rollup.config.mjs --failAfterWarnings",
@@ -45,7 +48,8 @@
     "test": "jest --verbose",
     "test:cov": "jest --verbose --coverage",
     "ts:check": "tsc -p tsconfig.build.json --noEmit",
-    "watch": "rollup --config rollup.config.mjs --watch --failAfterWarnings"
+    "watch": "rollup --config rollup.config.mjs --watch --failAfterWarnings",
+    "prepack": "pnpm exec ./scripts/pre-pack.sh"
   },
   "devDependencies": {
     "@commitlint/cli": "19.6.0",

scripts/pre-pack.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+# Run the Prettier check
+pnpm prettier:check &&
+
+# Run linting
+pnpm lint  &&
+
+# Run TypeScript type check
+pnpm ts:check &&
+
+# Run tests with coverage
+pnpm test:cov &&
+
+# Run the clean build
+pnpm build:clean

src/auth/factory/factory.ts

@@ -0,0 +1,83 @@
+import { StrapiSDKError } from '../../errors';
+
+import type { AuthProviderCreator, AuthProviderMap, CreateAuthProviderParams } from './types';
+import type { AuthProvider } from '../providers';
+
+/**
+ * A factory class responsible for creating and managing authentication providers.
+ *
+ * It facilitates the registration and creation of different authentication
+ * strategies which implement the AuthProvider interface.
+ *
+ * @template T_Providers Defines a map for authentication strategy names to their corresponding creator functions.
+ */
+export class AuthProviderFactory<T_Providers extends AuthProviderMap = {}> {
+  private readonly _registry = new Map<StringKeysOf<T_Providers>, AuthProviderCreator>();
+
+  /**
+   * Creates an instance of an authentication provider based on the specified strategy.
+   *
+   * @param authStrategy The authentication strategy name to be used for creating the provider.
+   * @param options Configuration options required to initialize the authentication provider.
+   *
+   * @returns An instance of an AuthProvider initialized with the given options.
+   *
+   * @throws {StrapiSDKError} Throws an error if the specified strategy is not registered in the factory.
+   *
+   * @example
+   * ```typescript
+   * const factory = new AuthProviderFactory();
+   *
+   * factory.register(
+   *   'api-token',
+   *   (options: ApiTokenAuthProviderOptions) => new ApiTokenAuthProvider(options)
+   * );
+   *
+   * const provider = factory.create('api-token', { jwt: 'token' });
+   * ```
+   */
+  create<T_Strategy extends StringKeysOf<T_Providers> | string>(
+    authStrategy: T_Strategy,
+    options: CreateAuthProviderParams<T_Providers, T_Strategy>
+  ): AuthProvider {
+    const creator = this._registry.get(authStrategy);
+
+    if (!creator) {
+      throw new StrapiSDKError(`Auth strategy "${authStrategy}" is not supported.`);
+    }
+
+    return creator(options);
+  }
+
+  /**
+   * Registers a new authentication strategy with the factory.
+   *
+   * @param strategy The name of the authentication strategy to register.
+   * @param creator A function that creates an instance of an authentication provider for the specified strategy.
+   *
+   * @returns The instance of AuthProviderFactory, for chaining purpose.
+   *
+   * @example
+   * ```typescript
+   * const factory = new AuthProviderFactory();
+   *
+   * factory
+   *  .register(
+   *    'api-token',
+   *    (options: ApiTokenAuthProviderOptions) => new ApiTokenAuthProvider(options)
+   *  )
+   *  .register(
+   *    'users-permissions',
+   *    (options: UsersPermissionsAuthProviderOptions) => new UsersPermissionsAuthProvider(options)
+   *  );
+   * ```
+   */
+  register<T_Strategy extends string, T_Creator extends AuthProviderCreator>(
+    strategy: T_Strategy,
+    creator: T_Creator
+  ) {
+    this._registry.set(strategy, creator);
+
+    return this as AuthProviderFactory<T_Providers & { [key in T_Strategy]: typeof creator }>;
+  }
+}

src/auth/factory/index.ts

@@ -0,0 +1 @@
+export * from './factory';

src/auth/factory/types.ts

@@ -0,0 +1,10 @@
+import type { AuthProvider } from '../providers';
+
+export type AuthProviderCreator<T = any> = (options: T) => AuthProvider;
+
+export type AuthProviderMap = { [key: string]: AuthProviderCreator };
+
+export type CreateAuthProviderParams<
+  T_Providers extends AuthProviderMap,
+  T_Strategy extends StringKeysOf<T_Providers>,
+> = T_Providers[T_Strategy] extends AuthProviderCreator<infer T_Options> ? T_Options : unknown;

src/auth/index.ts

@@ -0,0 +1,4 @@
+export * from './providers';
+export * from './factory';
+
+export * from './manager';