@malevich-studio/strapi-sdk-typescript 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_strapi_types_1 = require("./generate-strapi-types");
+(async () => {
+    await (0, generate_strapi_types_1.generateStrapiTypes)();
+})();

package/dist/generate-strapi-types.d.ts

@@ -0,0 +1,5 @@
+import 'dotenv/config';
+/**
+ * Main function to fetch Strapi (v5) data and generate the d.ts file
+ */
+export declare function generateStrapiTypes(): Promise<void>;

package/dist/generate-strapi-types.js

@@ -0,0 +1,245 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStrapiTypes = generateStrapiTypes;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+require("dotenv/config");
+const main_1 = __importDefault(require("./main"));
+var ConfigTypeKind;
+(function (ConfigTypeKind) {
+    ConfigTypeKind["CollectionType"] = "collectionType";
+    ConfigTypeKind["SingleType"] = "singleType";
+})(ConfigTypeKind || (ConfigTypeKind = {}));
+var AttributeType;
+(function (AttributeType) {
+    AttributeType["BigInteger"] = "biginteger";
+    AttributeType["Blocks"] = "blocks";
+    AttributeType["Boolean"] = "boolean";
+    AttributeType["Component"] = "component";
+    AttributeType["DateTime"] = "datetime";
+    AttributeType["Decimal"] = "decimal";
+    AttributeType["Email"] = "email";
+    AttributeType["Enumeration"] = "enumeration";
+    AttributeType["Integer"] = "integer";
+    AttributeType["Json"] = "json";
+    AttributeType["Media"] = "media";
+    AttributeType["Password"] = "password";
+    AttributeType["Relation"] = "relation";
+    AttributeType["String"] = "string";
+    AttributeType["Text"] = "text";
+    // RichText = 'richtext',
+})(AttributeType || (AttributeType = {}));
+var AttributeRelation;
+(function (AttributeRelation) {
+    AttributeRelation["MorphToMany"] = "morphToMany";
+    AttributeRelation["ManyToOne"] = "manyToOne";
+    AttributeRelation["ManyToMany"] = "manyToMany";
+    AttributeRelation["OneToMany"] = "oneToMany";
+    AttributeRelation["OneToOne"] = "oneToOne";
+})(AttributeRelation || (AttributeRelation = {}));
+function getComponentType(attribute) {
+    const componentTypeName = getContentTypeName(attribute.component);
+    return attribute.repeatable ? `${componentTypeName}[]` : componentTypeName;
+}
+function getRelationType(attribute) {
+    const ContentTypeName = getContentTypeName(attribute.target);
+    switch (attribute.relation) {
+        case AttributeRelation.ManyToMany:
+        case AttributeRelation.OneToMany:
+        case AttributeRelation.MorphToMany:
+            return `${ContentTypeName}[]`;
+        case AttributeRelation.ManyToOne:
+        case AttributeRelation.OneToOne:
+        default:
+            return ContentTypeName;
+    }
+}
+/**
+ * Maps basic Strapi types to TypeScript types
+ */
+function getAttributeType(attribute) {
+    switch (attribute.type) {
+        case AttributeType.String:
+        case AttributeType.Text:
+        case AttributeType.Password:
+        case AttributeType.Email:
+            return 'string';
+        case AttributeType.Integer:
+        case AttributeType.BigInteger:
+        case AttributeType.Decimal:
+            return 'number';
+        case AttributeType.Boolean:
+            return 'boolean';
+        case AttributeType.Relation:
+            return getRelationType(attribute);
+        case AttributeType.Component:
+            return getComponentType(attribute);
+        case AttributeType.DateTime:
+            return 'string'; // Usually, date/time fields come as strings from the API
+        case AttributeType.Json:
+            return 'object'; // Could be Record<string, unknown> if you want stricter typing
+        case AttributeType.Media:
+            // Media fields can be objects or arrays of objects representing files
+            // You can type them more specifically if needed
+            return 'any';
+        case AttributeType.Enumeration:
+            return `'${attribute.enum.join('\' | \'')}'`;
+        default:
+            // For unrecognized types, we check further below
+            break;
+    }
+}
+/**
+ * Returns the TypeScript interface name from a component UID
+ * e.g. "default.test-component" => "DefaultTestComponent"
+ */
+function getComponentName(uid) {
+    return uid
+        .split(/[\.\-]/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+/**
+ * Returns the TypeScript interface name from a content type UID
+ * e.g. "api::article.article" => "Article"
+ */
+function getContentTypeName(uid) {
+    // Usually, UIDs look like "api::<api-name>.<model-name>"
+    // We'll split at "::" and then take the part after the dot.
+    const namePart = uid.split('::')[1] || uid;
+    const modelName = namePart.split('.')[1] || namePart;
+    // Convert to PascalCase
+    return modelName
+        .split('-')
+        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('');
+}
+/**
+ * Generates a TS interface from a content type or component definition
+ */
+function generateTypeCode(name, attributes) {
+    const lines = [];
+    lines.push(`export type ${name} = {`);
+    // Strapi's default fields:
+    lines.push(`  id?: number;`);
+    lines.push(`  createdAt?: string;`);
+    lines.push(`  updatedAt?: string;`);
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const typeName = getAttributeType(attribute);
+        const isRequired = attribute.required ? '' : '?';
+        lines.push(`  ${attributeName}${isRequired}: ${typeName};`);
+    }
+    lines.push(`}`);
+    return lines.join('\n');
+}
+function generateQueryTypeCode(name, attributes) {
+    const fields = [];
+    const sort = [];
+    const filters = [];
+    filters.push(`export type ${name}Filters = Filters<{`);
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        fields.push(`'${attributeName}'`);
+        if ([
+            AttributeType.String,
+            AttributeType.Text,
+            AttributeType.Password,
+            AttributeType.Email,
+            AttributeType.Integer,
+            AttributeType.BigInteger,
+            AttributeType.Decimal,
+            AttributeType.Boolean,
+            AttributeType.DateTime,
+            AttributeType.Enumeration,
+        ].includes(attribute.type)) {
+            sort.push(`'${attributeName}'`);
+            sort.push(`'${attributeName}:asc'`);
+            sort.push(`'${attributeName}:desc'`);
+        }
+        const type = getAttributeType(attribute);
+        switch (attribute.type) {
+            case AttributeType.Relation:
+                filters.push(`  ${attributeName}?: ${getContentTypeName(attribute.target)}Filters;`);
+                break;
+            case AttributeType.Component:
+            case AttributeType.Media:
+            case AttributeType.Json:
+                break;
+            default:
+                filters.push(`  ${attributeName}?: FilterValue<${type}>;`);
+        }
+    }
+    filters.push(`}>`);
+    filters.push('');
+    const lines = [];
+    lines.push(...filters);
+    lines.push(`export type ${name}Query  = Query<`);
+    lines.push(`  ${fields.join(' | ')},`);
+    lines.push(`  ${sort.join(' | ')},`);
+    lines.push(`  ${name}Filters`);
+    lines.push(`>`);
+    return lines.join('\n');
+}
+/**
+ * Main function to fetch Strapi (v5) data and generate the d.ts file
+ */
+async function generateStrapiTypes() {
+    const strapi = new main_1.default(process.env.STRAPI_URL, process.env.STRAPI_TOKEN);
+    const contentTypes = (await strapi.request('content-type-builder/content-types')).data;
+    const components = (await strapi.request('content-type-builder/components')).data;
+    const allInterfaces = [];
+    for (const component of components) {
+        const componentName = getComponentName(component.uid);
+        const code = generateTypeCode(componentName, component.schema.attributes);
+        allInterfaces.push(code);
+    }
+    for (const contentType of contentTypes) {
+        if (!contentType.uid.startsWith('api::')) {
+            continue;
+        }
+        const modelName = getContentTypeName(contentType.uid);
+        allInterfaces.push(generateTypeCode(modelName, contentType.schema.attributes));
+        allInterfaces.push(generateQueryTypeCode(modelName, contentType.schema.attributes));
+    }
+    const output = allInterfaces.join('\n\n');
+    const outPath = path.join(process.cwd(), 'strapi-types.d.ts');
+    fs.writeFileSync(outPath, output, 'utf-8');
+    console.log(`✅ "strapi-types.d.ts" has been successfully generated!`);
+}

package/dist/main.d.ts

@@ -0,0 +1,68 @@
+type Response<T> = {
+    data: T[];
+    meta: {
+        pagination: {
+            total?: number;
+        } & ({
+            page: number;
+            pageSize: number;
+            pageCount?: number;
+        } | {
+            start: number;
+            limit: number;
+        });
+    };
+};
+export type Filters<T> = {
+    $or?: Filters<T>[];
+    $and?: Filters<T>[];
+    $not?: Filters<T>[];
+} | T;
+export type FilterValue<T> = {
+    $eq?: T;
+    $eqi?: string;
+    $ne?: T;
+    $nei?: string;
+    $lt?: T;
+    $lte?: T;
+    $gt?: T;
+    $gte?: T;
+    $in?: T[];
+    $notIn?: T[];
+    $contains?: string;
+    $notContains?: string;
+    $containsi?: string;
+    $notContainsi?: string;
+    $between?: [T, T];
+    $startsWith?: string;
+    $startsWithi?: string;
+    $endsWith?: string;
+    $endsWithi?: string;
+} | T;
+export type Query<Fields, Sort, Filters, Populate> = {
+    populate?: Populate;
+    fields?: Fields[] | '*';
+    filters?: Filters;
+    locale?: string;
+    status?: 'published' | 'draft';
+    sort?: Sort[] | Sort;
+    pagination?: {
+        withCount?: boolean;
+    } & ({
+        page?: number;
+        pageSize?: number;
+    } | {
+        start?: number;
+        limit?: number;
+    });
+};
+export default class Strapi {
+    private readonly url;
+    private readonly token;
+    constructor(url: string, token: string);
+    request<T>(endpoint: string, data?: object, params?: RequestInit): Promise<Response<T>>;
+    getDocuments<T, Q extends object>(endpoint: string, data?: Q, params?: RequestInit): Promise<Response<T>>;
+    getDocument<T, Q extends object>(endpoint: string, data?: Q, params?: RequestInit): Promise<Response<T>>;
+    create<T>(endpoint: string, data?: object, params?: RequestInit): Promise<Response<T>>;
+}
+export {};

package/dist/main.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qs_1 = __importDefault(require("qs"));
+class Strapi {
+    constructor(url, token) {
+        this.url = url;
+        this.token = token;
+    }
+    async request(endpoint, data = {}, params = {}) {
+        const baseUrl = `${this.url}/api/`;
+        const queryString = params.method === 'GET' ? qs_1.default.stringify(data) : '';
+        const url = queryString ? `${baseUrl}${endpoint}?${queryString}` : `${baseUrl}${endpoint}`;
+        console.log({
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'Content-Type': 'application/json',
+            },
+            cache: 'no-store',
+            ...(params.method && params.method !== 'GET' ? {
+                body: JSON.stringify({
+                    data,
+                })
+            } : {}),
+            ...params
+        });
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'Content-Type': 'application/json',
+            },
+            cache: 'no-store',
+            ...(params.method && params.method !== 'GET' ? {
+                body: JSON.stringify({
+                    data,
+                })
+            } : {}),
+            ...params
+        });
+        console.log(response);
+        if (!response.ok) {
+            throw new Error(`Помилка запиту до Strapi: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    async getDocuments(endpoint, data, params = {}) {
+        return await this.request(endpoint, data, {
+            method: 'GET',
+            ...params,
+        });
+    }
+    async getDocument(endpoint, data, params = {}) {
+        return await this.request(endpoint, data, {
+            method: 'GET',
+            ...params,
+        });
+    }
+    async create(endpoint, data = {}, params = {}) {
+        return await this.request(endpoint, data, {
+            method: 'POST',
+            ...params,
+        });
+    }
+}
+exports.default = Strapi;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@malevich-studio/strapi-sdk-typescript",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "bin": {
+    "generate-strapi-types": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.7",
+    "lodash": "^4.17.21",
+    "typescript": "^5.7.3"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}