@malevich-studio/strapi-sdk-typescript 1.0.3 → 1.0.4

package/dist/cli.mjs

@@ -0,0 +1,596 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import _ from 'lodash';
+import qs from 'qs';
+import mime from 'mime';
+import { readFile } from 'fs/promises';
+import { basename } from 'node:path';
+import 'dotenv/config';
+
+class Strapi {
+    constructor(url, token) {
+        this.url = url;
+        this.token = token;
+    }
+    async request(endpoint, data = {}, params = {}) {
+        const queryString = params.method === 'GET' ? qs.stringify(data) : '';
+        return await this.baseRequest(queryString ? `${endpoint}?${queryString}` : endpoint, _.merge({
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            ...(params.method && !['GET', 'DELETE'].includes(params.method) ? {
+                body: JSON.stringify({
+                    data,
+                })
+            } : {}),
+        }, params));
+    }
+    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,
+        });
+    }
+    async update(endpoint, id, data, params = {}) {
+        return await this.request(`${endpoint}/${id}`, data, {
+            method: 'PUT',
+            ...params,
+        });
+    }
+    async delete(endpoint, id, params = {}) {
+        return await this.request(`${endpoint}/${id}`, {}, {
+            method: 'DELETE',
+            ...params,
+        });
+    }
+    /**
+     * For Node.js
+     *
+     * @param files list of files names which will be uploaded, example: ['/app/data/cover.js']
+     */
+    async upload(files) {
+        const form = new FormData();
+        await Promise.all(files.map(async (item) => {
+            const fileBuffer = await readFile(item.path);
+            const file = new File([fileBuffer], item.filename || basename(item.path), { type: mime.getType(item.path) || 'image/jpeg' });
+            form.append('files', file);
+        }));
+        return await this.uploadForm(form);
+    }
+    async uploadForm(form) {
+        return await this.baseRequest('upload', {
+            method: 'POST',
+            body: form,
+        });
+    }
+    async baseRequest(endpoint, params = {}) {
+        const response = await fetch(`${this.url}/api/${endpoint}`, _.merge({
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        }, params));
+        if (!response.ok) {
+            console.log(`${this.url}/api/${endpoint}`);
+            console.log(_.merge({
+                headers: {
+                    Authorization: `Bearer ${this.token}`,
+                },
+            }, params));
+            console.log(response);
+            console.log(await response.json());
+            throw new Error(`Помилка запиту до Strapi: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+}
+
+/**
+ * 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('');
+}
+
+var AttributeMode;
+(function (AttributeMode) {
+    AttributeMode["Field"] = "field";
+    AttributeMode["Relation"] = "relation";
+})(AttributeMode || (AttributeMode = {}));
+class Base {
+    constructor(name, attribute) {
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'any';
+    }
+    getInputType() {
+        return this.getType();
+    }
+    getImports() {
+        return [];
+    }
+    getPackages() {
+        return [];
+    }
+    getFields() {
+        return [
+            this.name,
+        ];
+    }
+    getSortFields() {
+        return [
+            this.name,
+            `${this.name}:asc`,
+            `${this.name}:desc`,
+        ];
+    }
+    getPopulates() {
+        return [];
+    }
+    getFilters() {
+        return [
+            {
+                name: this.name,
+                type: `FilterValue<${this.getType()}>`,
+            },
+        ];
+    }
+    getMode() {
+        return AttributeMode.Field;
+    }
+}
+
+class BaseRelation extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'any';
+    }
+    getFields() {
+        return [];
+    }
+    getSortFields() {
+        return [];
+    }
+    getMode() {
+        return AttributeMode.Relation;
+    }
+}
+
+class Media extends BaseRelation {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return this.attribute.multiple ? 'File[]' : 'File';
+    }
+    getInputType() {
+        return 'RelationInput';
+    }
+    getPopulates() {
+        return [{
+                name: this.name,
+                type: 'FileQuery',
+            }];
+    }
+    getFilters() {
+        return [{
+                name: this.name,
+                type: 'FileFilters',
+            }];
+    }
+}
+
+/**
+ * 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('');
+}
+
+var AttributeRelation;
+(function (AttributeRelation) {
+    AttributeRelation["MorphToMany"] = "morphToMany";
+    AttributeRelation["ManyToOne"] = "manyToOne";
+    AttributeRelation["ManyToMany"] = "manyToMany";
+    AttributeRelation["OneToMany"] = "oneToMany";
+    AttributeRelation["OneToOne"] = "oneToOne";
+})(AttributeRelation || (AttributeRelation = {}));
+class Relation extends BaseRelation {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        if (this.attribute.relation === AttributeRelation.MorphToMany) {
+            return 'any';
+        }
+        const ContentTypeName = getContentTypeName(this.attribute.target);
+        switch (this.attribute.relation) {
+            case AttributeRelation.ManyToMany:
+            case AttributeRelation.OneToMany:
+                return `${ContentTypeName}[]`;
+            case AttributeRelation.ManyToOne:
+            case AttributeRelation.OneToOne:
+            default:
+                return ContentTypeName;
+        }
+    }
+    getInputType() {
+        return 'RelationInput';
+    }
+    getPopulates() {
+        if (this.attribute.relation === AttributeRelation.MorphToMany) {
+            return [];
+        }
+        return [{
+                name: this.name,
+                type: `${getContentTypeName(this.attribute.target)}Query`,
+            }];
+    }
+    getFilters() {
+        if (this.attribute.relation === AttributeRelation.MorphToMany) {
+            return [];
+        }
+        return [{
+                name: this.name,
+                type: `${getContentTypeName(this.attribute.target)}Filters`,
+            }];
+    }
+    getImports() {
+        return [
+            ...super.getImports(),
+            'import {RelationInput} from "@strapi/blocks-react-renderer";',
+        ];
+    }
+}
+
+class Enumeration extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return `'${this.attribute.enum.join('\' | \'')}'`;
+    }
+}
+
+class DateTime extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'string';
+    }
+}
+
+class Component extends BaseRelation {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        const componentName = getComponentName(this.attribute.component);
+        return this.attribute.repeatable ? `${componentName}[]` : componentName;
+    }
+    getInputType() {
+        return `${getComponentName(this.attribute.component)}Input`;
+    }
+    getPopulates() {
+        return [{
+                name: this.name,
+                type: `${getComponentName(this.attribute.component)}Query`,
+            }];
+    }
+    getFilters() {
+        return [
+        // {
+        //   name: this.name,
+        //   type: `${getComponentName(this.attribute.component)}Filters`,
+        // }
+        ];
+    }
+}
+
+class Blocks extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'BlocksContent';
+    }
+    getImports() {
+        return [
+            ...super.getImports(),
+            'import {BlocksContent} from "@strapi/blocks-react-renderer";',
+        ];
+    }
+    getPackages() {
+        return [
+            ...super.getPackages(),
+            '@strapi/blocks-react-renderer',
+        ];
+    }
+}
+
+class Json extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'object';
+    }
+    getFilters() {
+        return [];
+    }
+}
+
+class String extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'string';
+    }
+}
+
+class Number extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'number';
+    }
+}
+
+class Boolean extends Base {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'boolean';
+    }
+}
+
+const types = {
+    'string': String,
+    'text': String,
+    'password': String,
+    'email': String,
+    'integer': Number,
+    'biginteger': Number,
+    'decimal': Number,
+    'float': Number,
+    'boolean': Boolean,
+    'media': Media,
+    'relation': Relation,
+    'enumeration': Enumeration,
+    'datetime': DateTime,
+    'component': Component,
+    'blocks': Blocks,
+    'json': Json,
+};
+function getAttributeGenerator(name, attribute) {
+    if (!types[attribute.type]) {
+        throw new Error(`Attribute type "${attribute.type}" is not defined`);
+    }
+    return new types[attribute.type](name, attribute);
+}
+
+var ContentTypeKind;
+(function (ContentTypeKind) {
+    ContentTypeKind["CollectionType"] = "collectionType";
+    ContentTypeKind["SingleType"] = "singleType";
+})(ContentTypeKind || (ContentTypeKind = {}));
+function getContentTypeMethodName(uid) {
+    const typeName = getContentTypeName(uid);
+    return typeName.charAt(0).toLowerCase() + typeName.slice(1);
+}
+/**
+ * Generates a TS interface from a content type or component definition
+ */
+function generateResponseTypeCode(name, attributes) {
+    const lines = [];
+    lines.push(`export type ${name} = {`);
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const isRequired = attribute.required ? '' : '?';
+        lines.push(`  ${attributeName}${isRequired}: ${getAttributeGenerator(attributeName, attribute).getType()};`);
+    }
+    lines.push(`}`);
+    return lines.join('\n');
+}
+function generateQueryTypeCode(name, attributes) {
+    const fields = [];
+    const sortFields = [];
+    const filters = [];
+    const populates = [];
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const attributeGenerator = getAttributeGenerator(attributeName, attribute);
+        fields.push(...attributeGenerator.getFields());
+        sortFields.push(...attributeGenerator.getSortFields());
+        filters.push(...attributeGenerator.getFilters());
+        populates.push(...attributeGenerator.getPopulates());
+    }
+    const lines = [];
+    lines.push(`export type ${name}Filters = Filters<{`);
+    lines.push(...filters.map(({ name, type }) => `  ${name}?: ${type};`));
+    lines.push(`}>`);
+    lines.push('');
+    lines.push(`export type ${name}Populate = {`);
+    lines.push(...populates.map(({ name, type }) => `  ${name}?: ${type};`));
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`export type ${name}Query  = Query<`);
+    lines.push(`  ${fields.map(field => `'${field}'`).join(' | ')},`);
+    lines.push(`  ${sortFields.map(field => `'${field}'`).join(' | ')},`);
+    lines.push(`  ${name}Filters,`);
+    lines.push(`  ${name}Populate`);
+    lines.push(`>`);
+    return lines.join('\n');
+}
+function generateInputTypeCode(name, attributes) {
+    const fields = [];
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        const attributeGenerator = getAttributeGenerator(attributeName, attribute);
+        fields.push({
+            name: attributeName,
+            type: attributeGenerator.getInputType(),
+        });
+    }
+    const lines = [];
+    lines.push(`export type ${name}Input = {`);
+    lines.push(...fields.map(({ name, type }) => `  ${name}?: ${type};`));
+    lines.push(`}`);
+    return lines.join('\n');
+}
+function generateMethodsCode(contentType) {
+    const methods = [];
+    const modelName = getContentTypeName(contentType.uid);
+    if (contentType.schema.kind === ContentTypeKind.CollectionType) {
+        methods.push([
+            `  public async ${getContentTypeMethodName(contentType.schema.pluralName)}(query?: ${modelName}Query, params?: RequestInit) {`,
+            `    return await this.getDocuments<${modelName}, ${modelName}Query>('${contentType.schema.pluralName}', query, params);`,
+            '  }',
+        ].join('\n'));
+    }
+    methods.push([
+        `  public async ${getContentTypeMethodName(contentType.schema.singularName)}(query?: ${modelName}Query, params?: RequestInit) {`,
+        `    return await this.getDocument<${modelName}, ${modelName}Query>('${contentType.schema.singularName}', query, params);`,
+        '  }',
+    ].join('\n'));
+    methods.push([
+        `  public async create${getContentTypeName(contentType.schema.singularName)}(data: ${modelName}Input, params?: RequestInit) {`,
+        `    return await this.create<${modelName}, ${modelName}Input>('${contentType.schema.pluralName}', data, params);`,
+        '  }',
+    ].join('\n'));
+    methods.push([
+        `  public async update${getContentTypeName(contentType.schema.singularName)}(id: string, data: ${modelName}Input, params?: RequestInit) {`,
+        `    return await this.update<${modelName}, ${modelName}Input>('${contentType.schema.pluralName}', id, data, params);`,
+        '  }',
+    ].join('\n'));
+    methods.push([
+        `  public async delete${getContentTypeName(contentType.schema.singularName)}(id: string, params?: RequestInit) {`,
+        `    return await this.delete<${modelName}>('${contentType.schema.pluralName}', id, params);`,
+        '  }',
+    ].join('\n'));
+    return methods;
+}
+/**
+ * Main function to fetch Strapi (v5) data and generate the d.ts file
+ */
+async function generateStrapiTypes(strapi) {
+    const contentTypes = (await strapi.request('content-type-builder/content-types')).data;
+    const components = (await strapi.request('content-type-builder/components')).data;
+    const allInterfaces = [];
+    const methods = [];
+    for (const component of components) {
+        const componentName = getComponentName(component.uid);
+        const attributes = {
+            id: {
+                type: 'integer',
+            },
+            ...component.schema.attributes,
+        };
+        allInterfaces.push(generateResponseTypeCode(componentName, attributes));
+        allInterfaces.push(generateQueryTypeCode(componentName, attributes));
+        allInterfaces.push(generateInputTypeCode(componentName, attributes));
+    }
+    for (const contentType of contentTypes) {
+        if (!['api::', 'plugin::upload', 'plugin::users-permissions'].filter(prefix => contentType.uid.startsWith(prefix)).length) {
+            continue;
+        }
+        methods.push(...generateMethodsCode(contentType));
+        const modelName = getContentTypeName(contentType.uid);
+        const attributes = {
+            id: {
+                type: 'integer',
+            },
+            documentId: {
+                type: 'string',
+            },
+            createdAt: {
+                type: 'datetime',
+            },
+            updatedAt: {
+                type: 'datetime',
+            },
+            ...contentType.schema.attributes,
+        };
+        allInterfaces.push(generateResponseTypeCode(modelName, attributes));
+        allInterfaces.push(generateQueryTypeCode(modelName, attributes));
+        allInterfaces.push(generateInputTypeCode(modelName, attributes));
+    }
+    const output = [
+        'import {Strapi as StrapiBase, Query, Filters, FilterValue, RelationInput} from "@malevich-studio/strapi-sdk-typescript";',
+        'import {BlocksContent} from "@strapi/blocks-react-renderer";',
+        '',
+        'export default class Strapi extends StrapiBase {',
+        methods.join('\n\n'),
+        '}',
+        '',
+        allInterfaces.join('\n\n'),
+        '',
+    ].join('\n');
+    const outPath = path.join(process.cwd(), 'strapi.ts');
+    fs.writeFileSync(outPath, output, 'utf-8');
+    console.log(`✅ "strapi.ts" has been successfully generated!`);
+}
+
+if (!process.env.STRAPI_URL || !process.env.STRAPI_TOKEN) {
+    throw new Error('STRAPI_URL and STRAPI_TOKEN must be provided.');
+}
+const strapi = new Strapi(process.env.STRAPI_URL, process.env.STRAPI_TOKEN);
+(async () => {
+    await generateStrapiTypes(strapi);
+})();
+//# sourceMappingURL=cli.mjs.map