@malevich-studio/strapi-sdk-typescript 1.0.0 → 1.0.2

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import 'dotenv/config';

package/dist/cli.js

@@ -2,6 +2,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const generate_strapi_types_1 = require("./generate-strapi-types");
+require("dotenv/config");
+const main_1 = require("./main");
+const strapi = new main_1.Strapi(process.env.STRAPI_URL, process.env.STRAPI_TOKEN);
 (async () => {
-    await (0, generate_strapi_types_1.generateStrapiTypes)();
+    await (0, generate_strapi_types_1.generateStrapiTypes)(strapi);
 })();

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

@@ -1,5 +1,7 @@
-import 'dotenv/config';
+import { Strapi } from "./main";
+import type { RelationInput } from "./generator/attributes/relation";
+export type { RelationInput };
 /**
  * Main function to fetch Strapi (v5) data and generate the d.ts file
  */
-export declare function generateStrapiTypes(): Promise<void>;
+export declare function generateStrapiTypes(strapi: Strapi): Promise<void>;

package/dist/generate-strapi-types.js

@@ -39,207 +39,167 @@ 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('');
+const get_component_name_1 = require("./generator/utils/get-component-name");
+const attributes_1 = __importDefault(require("./generator/attributes"));
+const get_content_type_name_1 = require("./generator/utils/get-content-type-name");
+var ContentTypeKind;
+(function (ContentTypeKind) {
+    ContentTypeKind["CollectionType"] = "collectionType";
+    ContentTypeKind["SingleType"] = "singleType";
+})(ContentTypeKind || (ContentTypeKind = {}));
+function getContentTypeMethodName(uid) {
+    const typeName = (0, get_content_type_name_1.getContentTypeName)(uid);
+    return typeName.charAt(0).toLowerCase() + typeName.slice(1);
 }
 /**
  * Generates a TS interface from a content type or component definition
  */
-function generateTypeCode(name, attributes) {
+function generateResponseTypeCode(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(`  ${attributeName}${isRequired}: ${(0, attributes_1.default)(attributeName, attribute).getType()};`);
     }
     lines.push(`}`);
     return lines.join('\n');
 }
 function generateQueryTypeCode(name, attributes) {
     const fields = [];
-    const sort = [];
+    const sortFields = [];
     const filters = [];
-    filters.push(`export type ${name}Filters = Filters<{`);
+    const populates = [];
     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}>;`);
-        }
+        const attributeGenerator = (0, attributes_1.default)(attributeName, attribute);
+        fields.push(...attributeGenerator.getFields());
+        sortFields.push(...attributeGenerator.getSortFields());
+        filters.push(...attributeGenerator.getFilters());
+        populates.push(...attributeGenerator.getPopulates());
     }
-    filters.push(`}>`);
-    filters.push('');
     const lines = [];
-    lines.push(...filters);
+    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.join(' | ')},`);
-    lines.push(`  ${sort.join(' | ')},`);
-    lines.push(`  ${name}Filters`);
+    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 = (0, attributes_1.default)(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 = (0, get_content_type_name_1.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${(0, get_content_type_name_1.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${(0, get_content_type_name_1.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${(0, get_content_type_name_1.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() {
-    const strapi = new main_1.default(process.env.STRAPI_URL, process.env.STRAPI_TOKEN);
+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 code = generateTypeCode(componentName, component.schema.attributes);
-        allInterfaces.push(code);
+        const componentName = (0, get_component_name_1.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 (!contentType.uid.startsWith('api::')) {
+        if (!['api::', 'plugin::upload', 'plugin::users-permissions'].filter(prefix => contentType.uid.startsWith(prefix)).length) {
             continue;
         }
-        const modelName = getContentTypeName(contentType.uid);
-        allInterfaces.push(generateTypeCode(modelName, contentType.schema.attributes));
-        allInterfaces.push(generateQueryTypeCode(modelName, contentType.schema.attributes));
+        methods.push(...generateMethodsCode(contentType));
+        const modelName = (0, get_content_type_name_1.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 = allInterfaces.join('\n\n');
-    const outPath = path.join(process.cwd(), 'strapi-types.d.ts');
+    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-types.d.ts" has been successfully generated!`);
+    console.log(`✅ "strapi.ts" has been successfully generated!`);
 }

package/dist/generator/attributes/base-relation.d.ts

@@ -0,0 +1,10 @@
+import Base, { AttributeMode, BaseAttribute } from "./base";
+export default class BaseRelation extends Base {
+    protected readonly name: string;
+    protected readonly attribute: BaseAttribute;
+    constructor(name: string, attribute: BaseAttribute);
+    getType(): string;
+    getFields(): string[];
+    getSortFields(): string[];
+    getMode(): AttributeMode;
+}

package/dist/generator/attributes/base-relation.js

@@ -0,0 +1,56 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importStar(require("./base"));
+class BaseRelation extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'any';
+    }
+    getFields() {
+        return [];
+    }
+    getSortFields() {
+        return [];
+    }
+    getMode() {
+        return base_1.AttributeMode.Relation;
+    }
+}
+exports.default = BaseRelation;

package/dist/generator/attributes/base.d.ts

@@ -0,0 +1,27 @@
+export type BaseAttribute = {
+    configurable?: boolean;
+    required?: boolean;
+    private?: boolean;
+};
+export declare enum AttributeMode {
+    Field = "field",
+    Relation = "relation"
+}
+export type FieldType = {
+    name: string;
+    type: string;
+};
+export default class Base {
+    protected readonly name: string;
+    protected readonly attribute: BaseAttribute;
+    constructor(name: string, attribute: BaseAttribute);
+    getType(): string;
+    getInputType(): string;
+    getImports(): string[];
+    getPackages(): string[];
+    getFields(): string[];
+    getSortFields(): string[];
+    getPopulates(): FieldType[];
+    getFilters(): FieldType[];
+    getMode(): AttributeMode;
+}

package/dist/generator/attributes/base.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributeMode = void 0;
+var AttributeMode;
+(function (AttributeMode) {
+    AttributeMode["Field"] = "field";
+    AttributeMode["Relation"] = "relation";
+})(AttributeMode || (exports.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;
+    }
+}
+exports.default = Base;

package/dist/generator/attributes/blocks.d.ts

@@ -0,0 +1,12 @@
+import Base, { BaseAttribute } from "./base";
+export type BlocksAttribute = BaseAttribute & {
+    type: 'blocks';
+};
+export default class Blocks extends Base {
+    protected readonly name: string;
+    protected readonly attribute: BlocksAttribute;
+    constructor(name: string, attribute: BlocksAttribute);
+    getType(): string;
+    getImports(): string[];
+    getPackages(): string[];
+}

package/dist/generator/attributes/blocks.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class Blocks extends base_1.default {
+    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',
+        ];
+    }
+}
+exports.default = Blocks;

package/dist/generator/attributes/boolean.d.ts

@@ -0,0 +1,10 @@
+import Base, { BaseAttribute } from "./base";
+export type BooleanAttribute = BaseAttribute & {
+    type: 'boolean';
+};
+export default class Boolean extends Base {
+    protected readonly name: string;
+    protected readonly attribute: BooleanAttribute;
+    constructor(name: string, attribute: BooleanAttribute);
+    getType(): string;
+}

package/dist/generator/attributes/boolean.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class Boolean extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'boolean';
+    }
+}
+exports.default = Boolean;

package/dist/generator/attributes/component.d.ts

@@ -0,0 +1,20 @@
+import { BaseAttribute, FieldType } from "./base";
+import BaseRelation from "./base-relation";
+export type ComponentAttribute = BaseAttribute & {
+    type: 'component';
+    repeatable: boolean;
+    component: string;
+    min?: number;
+};
+export default class Component extends BaseRelation {
+    protected readonly name: string;
+    protected readonly attribute: ComponentAttribute;
+    constructor(name: string, attribute: ComponentAttribute);
+    getType(): string;
+    getInputType(): string;
+    getPopulates(): {
+        name: string;
+        type: string;
+    }[];
+    getFilters(): FieldType[];
+}

package/dist/generator/attributes/component.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_component_name_1 = require("../utils/get-component-name");
+const base_relation_1 = __importDefault(require("./base-relation"));
+class Component extends base_relation_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        const componentName = (0, get_component_name_1.getComponentName)(this.attribute.component);
+        return this.attribute.repeatable ? `${componentName}[]` : componentName;
+    }
+    getInputType() {
+        return `${(0, get_component_name_1.getComponentName)(this.attribute.component)}Input`;
+    }
+    getPopulates() {
+        return [{
+                name: this.name,
+                type: `${(0, get_component_name_1.getComponentName)(this.attribute.component)}Query`,
+            }];
+    }
+    getFilters() {
+        return [
+        // {
+        //   name: this.name,
+        //   type: `${getComponentName(this.attribute.component)}Filters`,
+        // }
+        ];
+    }
+}
+exports.default = Component;

package/dist/generator/attributes/date-time.d.ts

@@ -0,0 +1,10 @@
+import Base, { BaseAttribute } from "./base";
+export type DateTimeAttribute = BaseAttribute & {
+    type: 'datetime';
+};
+export default class DateTime extends Base {
+    protected readonly name: string;
+    protected readonly attribute: DateTimeAttribute;
+    constructor(name: string, attribute: DateTimeAttribute);
+    getType(): string;
+}

package/dist/generator/attributes/date-time.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class DateTime extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'string';
+    }
+}
+exports.default = DateTime;

package/dist/generator/attributes/enumeration.d.ts

@@ -0,0 +1,12 @@
+import Base, { BaseAttribute } from "./base";
+export type EnumerationAttribute = BaseAttribute & {
+    type: 'enumeration';
+    enum: string[];
+    default: string;
+};
+export default class Enumeration extends Base {
+    protected readonly name: string;
+    protected readonly attribute: EnumerationAttribute;
+    constructor(name: string, attribute: EnumerationAttribute);
+    getType(): string;
+}

package/dist/generator/attributes/enumeration.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class Enumeration extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return `'${this.attribute.enum.join('\' | \'')}'`;
+    }
+}
+exports.default = Enumeration;

package/dist/generator/attributes/index.d.ts

@@ -0,0 +1,4 @@
+import Base, { BaseAttribute } from "./base";
+export default function getAttributeGenerator(name: string, attribute: BaseAttribute & {
+    type: string;
+}): Base;

package/dist/generator/attributes/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getAttributeGenerator;
+const string_1 = __importDefault(require("./string"));
+const number_1 = __importDefault(require("./number"));
+const media_1 = __importDefault(require("./media"));
+const relation_1 = __importDefault(require("./relation"));
+const enumeration_1 = __importDefault(require("./enumeration"));
+const date_time_1 = __importDefault(require("./date-time"));
+const component_1 = __importDefault(require("./component"));
+const blocks_1 = __importDefault(require("./blocks"));
+const json_1 = __importDefault(require("./json"));
+const boolean_1 = __importDefault(require("./boolean"));
+const types = {
+    'string': string_1.default,
+    'text': string_1.default,
+    'password': string_1.default,
+    'email': string_1.default,
+    'integer': number_1.default,
+    'biginteger': number_1.default,
+    'decimal': number_1.default,
+    'float': number_1.default,
+    'boolean': boolean_1.default,
+    'media': media_1.default,
+    'relation': relation_1.default,
+    'enumeration': enumeration_1.default,
+    'datetime': date_time_1.default,
+    'component': component_1.default,
+    'blocks': blocks_1.default,
+    'json': json_1.default,
+};
+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);
+}

package/dist/generator/attributes/json.d.ts

@@ -0,0 +1,11 @@
+import Base, { BaseAttribute } from "./base";
+export type JsonAttribute = BaseAttribute & {
+    type: 'json';
+};
+export default class Json extends Base {
+    protected readonly name: string;
+    protected readonly attribute: JsonAttribute;
+    constructor(name: string, attribute: JsonAttribute);
+    getType(): string;
+    getFilters(): any[];
+}

package/dist/generator/attributes/json.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class Json extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'object';
+    }
+    getFilters() {
+        return [];
+    }
+}
+exports.default = Json;

package/dist/generator/attributes/media.d.ts

@@ -0,0 +1,21 @@
+import { BaseAttribute } from "./base";
+import BaseRelation from "./base-relation";
+export type MediaAttribute = BaseAttribute & {
+    type: 'media';
+    multiple: boolean;
+    allowedTypes: string[];
+};
+export default class Media extends BaseRelation {
+    protected readonly name: string;
+    protected readonly attribute: MediaAttribute;
+    constructor(name: string, attribute: MediaAttribute);
+    getType(): "File[]" | "File";
+    getPopulates(): {
+        name: string;
+        type: string;
+    }[];
+    getFilters(): {
+        name: string;
+        type: string;
+    }[];
+}

package/dist/generator/attributes/media.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_relation_1 = __importDefault(require("./base-relation"));
+class Media extends base_relation_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return this.attribute.multiple ? 'File[]' : 'File';
+    }
+    getPopulates() {
+        return [{
+                name: this.name,
+                type: 'FileQuery',
+            }];
+    }
+    getFilters() {
+        return [{
+                name: this.name,
+                type: 'FileFilters',
+            }];
+    }
+}
+exports.default = Media;

package/dist/generator/attributes/number.d.ts

@@ -0,0 +1,12 @@
+import Base, { BaseAttribute } from "./base";
+export type NumberAttribute = BaseAttribute & {
+    type: 'integer' | 'biginteger' | 'decimal';
+    min?: number;
+    max?: number;
+};
+export default class Number extends Base {
+    protected readonly name: string;
+    protected readonly attribute: NumberAttribute;
+    constructor(name: string, attribute: NumberAttribute);
+    getType(): string;
+}

package/dist/generator/attributes/number.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class Number extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'number';
+    }
+}
+exports.default = Number;

package/dist/generator/attributes/relation.d.ts

@@ -0,0 +1,48 @@
+import { BaseAttribute } from "./base";
+import BaseRelation from "./base-relation";
+export declare enum AttributeRelation {
+    MorphToMany = "morphToMany",
+    ManyToOne = "manyToOne",
+    ManyToMany = "manyToMany",
+    OneToMany = "oneToMany",
+    OneToOne = "oneToOne"
+}
+type RelationData = {
+    documentId: string;
+    before?: string;
+    after?: string;
+    start?: true;
+    end?: true;
+    locale?: string;
+    status?: 'published' | 'draft';
+} | string;
+export type RelationInput = {
+    connect?: RelationData[];
+    disconnect?: RelationData[];
+    set?: RelationData[];
+} | RelationData[];
+export type RelationAttribute = BaseAttribute & {
+    type: 'relation';
+    relation: AttributeRelation;
+    target: string;
+    targetAttribute?: string;
+    inversedBy: string;
+    mappedBy: string;
+};
+export default class Relation extends BaseRelation {
+    protected readonly name: string;
+    protected readonly attribute: RelationAttribute;
+    constructor(name: string, attribute: RelationAttribute);
+    getType(): string;
+    getInputType(): string;
+    getPopulates(): {
+        name: string;
+        type: string;
+    }[];
+    getFilters(): {
+        name: string;
+        type: string;
+    }[];
+    getImports(): string[];
+}
+export {};

package/dist/generator/attributes/relation.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributeRelation = void 0;
+const get_content_type_name_1 = require("../utils/get-content-type-name");
+const base_relation_1 = __importDefault(require("./base-relation"));
+var AttributeRelation;
+(function (AttributeRelation) {
+    AttributeRelation["MorphToMany"] = "morphToMany";
+    AttributeRelation["ManyToOne"] = "manyToOne";
+    AttributeRelation["ManyToMany"] = "manyToMany";
+    AttributeRelation["OneToMany"] = "oneToMany";
+    AttributeRelation["OneToOne"] = "oneToOne";
+})(AttributeRelation || (exports.AttributeRelation = AttributeRelation = {}));
+class Relation extends base_relation_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        if (this.attribute.relation === AttributeRelation.MorphToMany) {
+            return 'any';
+        }
+        const ContentTypeName = (0, get_content_type_name_1.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: `${(0, get_content_type_name_1.getContentTypeName)(this.attribute.target)}Query`,
+            }];
+    }
+    getFilters() {
+        if (this.attribute.relation === AttributeRelation.MorphToMany) {
+            return [];
+        }
+        return [{
+                name: this.name,
+                type: `${(0, get_content_type_name_1.getContentTypeName)(this.attribute.target)}Filters`,
+            }];
+    }
+    getImports() {
+        return [
+            ...super.getImports(),
+            'import {RelationInput} from "@strapi/blocks-react-renderer";',
+        ];
+    }
+}
+exports.default = Relation;

package/dist/generator/attributes/string.d.ts

@@ -0,0 +1,13 @@
+import Base, { BaseAttribute } from "./base";
+export type StringAttribute = BaseAttribute & {
+    type: 'text' | 'string' | 'password' | 'email';
+    minLength?: number;
+    maxLength?: number;
+    searchable?: boolean;
+};
+export default class String extends Base {
+    protected readonly name: string;
+    protected readonly attribute: StringAttribute;
+    constructor(name: string, attribute: StringAttribute);
+    getType(): string;
+}

package/dist/generator/attributes/string.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+class String extends base_1.default {
+    constructor(name, attribute) {
+        super(name, attribute);
+        this.name = name;
+        this.attribute = attribute;
+    }
+    getType() {
+        return 'string';
+    }
+}
+exports.default = String;

package/dist/generator/utils/get-component-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the TypeScript interface name from a component UID
+ * e.g. "default.test-component" => "DefaultTestComponent"
+ */
+export declare function getComponentName(uid: string): string;

package/dist/generator/utils/get-component-name.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentName = getComponentName;
+/**
+ * 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('');
+}

package/dist/generator/utils/get-content-type-name.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the TypeScript interface name from a content type UID
+ * e.g. "api::article.article" => "Article"
+ */
+export declare function getContentTypeName(uid: string): string;

package/dist/generator/utils/get-content-type-name.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContentTypeName = getContentTypeName;
+/**
+ * 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('');
+}

package/dist/main.d.ts

@@ -1,5 +1,5 @@
 type Response<T> = {
-    data: T[];
+    data: T;
     meta: {
         pagination: {
             total?: number;
@@ -56,13 +56,15 @@ export type Query<Fields, Sort, Filters, Populate> = {
         limit?: number;
     });
 };
-export default class Strapi {
+export declare 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>>;
+    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>>;
+    create<T, Q extends object>(endpoint: string, data: Q, params?: RequestInit): Promise<Response<T>>;
+    update<T, Q extends object>(endpoint: string, id: string, data: Q, params?: RequestInit): Promise<Response<T>>;
+    delete<T>(endpoint: string, id: string, params?: RequestInit): Promise<Response<T>>;
 }
 export {};

package/dist/main.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strapi = void 0;
 const qs_1 = __importDefault(require("qs"));
 class Strapi {
     constructor(url, token) {
@@ -13,26 +14,13 @@ class Strapi {
         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' ? {
+            ...(params.method && !['GET', 'DELETE'].includes(params.method) ? {
                 body: JSON.stringify({
                     data,
                 })
@@ -57,11 +45,23 @@ class Strapi {
             ...params,
         });
     }
-    async create(endpoint, data = {}, 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,
+        });
+    }
 }
-exports.default = Strapi;
+exports.Strapi = Strapi;

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@malevich-studio/strapi-sdk-typescript",
-  "version": "1.0.0",
-  "main": "dist/index.js",
+  "version": "1.0.2",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
   "bin": {
     "generate-strapi-types": "dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
     "build": "tsc",