strapi-rest-lite 0.1.0

package/README.md

@@ -0,0 +1,65 @@
+# strapi-rest-lite
+
+Kleines, generisches Strapi-REST-SDK zum Wiederverwenden:
+
+- HTTP-Client (`createHttpClient`) mit optionalem Bearer-Token
+- Collection-Repository (`createCollectionRepository`) und Service-Fabrik (`createCollectionService`, `withDefaults`)
+- Query-Types für Strapi (filters, populate, sort, pagination)
+- Media-Helper (`resolveMediaUrl`)
+
+## Installation (lokal / Git)
+
+```bash
+# lokal (Monorepo)
+pnpm add ./packages/strapi-sdk
+# oder npm install ./packages/strapi-sdk
+# oder via Git-URL/npm, sobald veröffentlicht: npm i strapi-rest-lite
+```
+
+## Verwendung
+
+```ts
+import { createHttpClient, createCollectionRepository, createCollectionService } from 'strapi-rest-lite'
+
+const client = createHttpClient({
+  baseURL: process.env.NUXT_PUBLIC_API_BASE || 'http://localhost:1337',
+  token: process.env.STRAPI_TOKEN, // optional
+})
+
+// Repository + Service für einen Typ
+const articleRepo = createCollectionRepository<Article>('articles', client)
+const articleService = createCollectionService(articleRepo)
+
+// Query-Beispiel
+const articles = await articleService.list({
+  populate: '*',
+  filters: { category: { slug: { $eq: 'news' } } },
+  sort: ['publishedAt:desc'],
+})
+```
+
+### Defaults einbetten
+
+```ts
+import { withDefaults } from 'strapi-rest-lite'
+
+const createArticleService = withDefaults(createCollectionService, {
+  populate: '*',
+  sort: ['publishedAt:desc', 'createdAt:desc'],
+})
+
+const articleService = createArticleService(articleRepo)
+```
+
+### Media-URL
+
+```ts
+import { resolveMediaUrl } from 'strapi-rest-lite'
+
+const fullUrl = resolveMediaUrl(article.cover?.url, process.env.NUXT_PUBLIC_API_BASE)
+```
+
+## Hinweise
+
+- Typen (Article, Category, …) projektabhängig definieren oder aus Strapi generieren.
+- Für Nuxt/Composables kannst du wie bisher eigene `useXYZ`-Hooks auf Basis des Services schreiben.

package/dist/collection-repository.d.ts

@@ -0,0 +1,7 @@
+import type { HttpClient, RepositoryQuery, StrapiListResponse, StrapiSingleResponse } from './types';
+export interface CollectionRepository<T> {
+    list(query?: RepositoryQuery): Promise<StrapiListResponse<T>>;
+    get(id: number | string, query?: RepositoryQuery): Promise<StrapiSingleResponse<T>>;
+    getBySlug(slug: string, query?: RepositoryQuery): Promise<StrapiListResponse<T>>;
+}
+export declare const createCollectionRepository: <T>(collection: string, client: HttpClient) => CollectionRepository<T>;

package/dist/collection-repository.js

@@ -0,0 +1,16 @@
+const apiPath = (collection) => `/api/${collection}`;
+export const createCollectionRepository = (collection, client) => {
+    return {
+        list: (query) => client.get(apiPath(collection), { query }),
+        get: (id, query) => client.get(`${apiPath(collection)}/${id}`, { query }),
+        getBySlug: (slug, query) => client.get(apiPath(collection), {
+            query: {
+                ...(query ?? {}),
+                filters: {
+                    ...(query?.filters ?? {}),
+                    slug: { $eq: slug },
+                },
+            },
+        }),
+    };
+};

package/dist/collection-service.d.ts

@@ -0,0 +1,9 @@
+import type { CollectionRepository } from './collection-repository';
+import type { RepositoryQuery, StrapiListResponse, StrapiSingleResponse } from './types';
+export interface CollectionService<T> {
+    list(query?: RepositoryQuery): Promise<StrapiListResponse<T>>;
+    get(id: number | string, query?: RepositoryQuery): Promise<StrapiSingleResponse<T>>;
+    getBySlug(slug: string, query?: RepositoryQuery): Promise<StrapiListResponse<T>>;
+}
+export declare const createCollectionService: <T>(repository: CollectionRepository<T>) => CollectionService<T>;
+export declare const withDefaults: <T>(factory: (repo: CollectionRepository<T>) => CollectionService<T>, defaults: RepositoryQuery) => (repo: CollectionRepository<T>) => CollectionService<T>;

package/dist/collection-service.js

@@ -0,0 +1,13 @@
+export const createCollectionService = (repository) => ({
+    list: (query) => repository.list(query),
+    get: (id, query) => repository.get(id, query),
+    getBySlug: (slug, query) => repository.getBySlug(slug, query),
+});
+export const withDefaults = (factory, defaults) => (repo) => {
+    const base = factory(repo);
+    return {
+        list: (query) => base.list({ ...defaults, ...(query ?? {}) }),
+        get: (id, query) => base.get(id, { ...defaults, ...(query ?? {}) }),
+        getBySlug: (slug, query) => base.getBySlug(slug, { ...defaults, ...(query ?? {}) }),
+    };
+};

package/dist/http-client.d.ts

@@ -0,0 +1,7 @@
+import type { FetchLike, HttpClient } from './types';
+export interface HttpClientOptions {
+    baseURL: string;
+    token?: string;
+    fetch?: FetchLike;
+}
+export declare const createHttpClient: ({ baseURL, token, fetch: fetchImpl }: HttpClientOptions) => HttpClient;

package/dist/http-client.js

@@ -0,0 +1,33 @@
+import qs from 'qs';
+const buildUrl = (baseURL, path, query) => {
+    const normalized = path.startsWith('/') ? path : `/${path}`;
+    const qsPart = query && Object.keys(query).length ? `?${qs.stringify(query, { encodeValuesOnly: true })}` : '';
+    return `${baseURL}${normalized}${qsPart}`;
+};
+export const createHttpClient = ({ baseURL, token, fetch: fetchImpl }) => {
+    const f = fetchImpl ?? fetch;
+    const request = async (method, path, body, options) => {
+        const url = buildUrl(baseURL, path, options?.query);
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+            ...(options?.headers ?? {}),
+        };
+        const res = await f(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            const message = await res.text().catch(() => res.statusText);
+            throw new Error(`HTTP ${res.status} ${res.statusText}: ${message}`);
+        }
+        return (await res.json());
+    };
+    return {
+        get: (path, options) => request('GET', path, undefined, options),
+        post: (path, body, options) => request('POST', path, body, options),
+        put: (path, body, options) => request('PUT', path, body, options),
+        delete: (path, options) => request('DELETE', path, undefined, options),
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './http-client';
+export * from './collection-repository';
+export * from './collection-service';
+export * from './media';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './http-client';
+export * from './collection-repository';
+export * from './collection-service';
+export * from './media';

package/dist/media.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Converts Strapi media URLs to absolute URLs based on the API base URL.
+ */
+export declare const resolveMediaUrl: (url?: string | null, apiBase?: string) => string | null;

package/dist/media.js

@@ -0,0 +1,12 @@
+/**
+ * Converts Strapi media URLs to absolute URLs based on the API base URL.
+ */
+export const resolveMediaUrl = (url, apiBase) => {
+    if (!url)
+        return null;
+    if (url.startsWith('http'))
+        return url;
+    if (!apiBase)
+        return url;
+    return `${apiBase}${url}`;
+};

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+export type FetchLike = typeof fetch;
+export interface HttpRequestOptions {
+    query?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+export interface HttpClient {
+    get<T = unknown>(path: string, options?: HttpRequestOptions): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown, options?: HttpRequestOptions): Promise<T>;
+    put<T = unknown>(path: string, body?: unknown, options?: HttpRequestOptions): Promise<T>;
+    delete<T = unknown>(path: string, options?: HttpRequestOptions): Promise<T>;
+}
+export interface RepositoryQuery {
+    filters?: Record<string, unknown>;
+    populate?: '*' | Record<string, unknown> | Array<string | Record<string, unknown>>;
+    sort?: string[] | string;
+    pagination?: {
+        page?: number;
+        pageSize?: number;
+        start?: number;
+        limit?: number;
+    };
+    fields?: string[];
+    [key: string]: unknown;
+}
+export interface StrapiListResponse<T> {
+    data: T[];
+    meta: Record<string, unknown>;
+}
+export interface StrapiSingleResponse<T> {
+    data: T | null;
+    meta: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "strapi-rest-lite",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "qs": "^6.12.0"
+  },
+  "devDependencies": {
+    "@types/qs": "^6.9.16"
+  },
+  "peerDependencies": {
+    "node-fetch": "^3.0.0"
+  }
+}