simple-strapi 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 Ernesto Bellei, hund.studio
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/client.d.ts

@@ -0,0 +1,103 @@
+import { InferNumber, NumberField, NumberOptions } from "./fields/number";
+import { InferText, TextField, TextOptions } from "./fields/text";
+import { InferRelationHasMany, RelationHasManyField, RelationHasManyOptions } from "./fields/relation";
+import { DynamicField, DynamicOptions, InferDynamic } from "./fields/dynamic";
+import { ComponentRepeatableField, ComponentRepeatableOptions, ComponentSingleField, ComponentSingleOptions, InferComponentRepeatable, InferComponentSingle } from "./fields/component";
+import { InferMediaSingle, MediaSingleField, MediaSingleOptions } from "./fields/media";
+import { EnumerationField, EnumerationOptions, InferEnumeration } from "./fields/enumeration";
+import { InferRichTextBlocks, RichTextBlocksField, RichTextBlocksOptions } from "./fields/richText";
+type RequestParams = Record<string, any>;
+type EntityRequest<P = {}> = {
+    params?: RequestParams;
+    headers?: Record<string, string>;
+} & P;
+export type SchemaField = TextField | NumberField | RelationHasManyField | DynamicField | ComponentSingleField | ComponentRepeatableField | MediaSingleField | EnumerationField | RichTextBlocksField;
+export type Schema = Record<string, SchemaField>;
+export type InferSchema<S extends Schema> = {
+    [K in keyof S]: S[K] extends ["text", infer O extends TextOptions] ? InferText<O> : S[K] extends ["number", infer O extends NumberOptions] ? InferNumber<O> : S[K] extends [
+        "relation.hasMany",
+        infer R extends Schema,
+        infer O extends RelationHasManyOptions
+    ] ? InferRelationHasMany<R, O> : S[K] extends [
+        "component.single",
+        infer R extends Schema,
+        infer O extends ComponentSingleOptions
+    ] ? InferComponentSingle<R, O> : S[K] extends [
+        "component.repeatable",
+        infer R extends Schema,
+        infer O extends ComponentRepeatableOptions
+    ] ? InferComponentRepeatable<R, O> : S[K] extends [
+        "dynamic",
+        infer B extends Record<string, Schema>,
+        infer O extends DynamicOptions
+    ] ? InferDynamic<B, O> : S[K] extends ["media.single", infer O extends MediaSingleOptions] ? InferMediaSingle<O> : S[K] extends [
+        "enumeration",
+        infer V extends readonly [string, ...string[]],
+        infer O extends EnumerationOptions
+    ] ? InferEnumeration<V, O> : S[K] extends ["richText.blocks", infer O extends RichTextBlocksOptions] ? InferRichTextBlocks<O> : never;
+};
+declare class Client {
+    private options;
+    private static headers;
+    static create(endpoint: string | URL, { auth, ...options }?: EntityRequest<{
+        auth?: {
+            email: string;
+            password: string;
+        } | string;
+    }>): Promise<Client>;
+    private static getRequestURL;
+    static getToken(auth: {
+        email: string;
+        password: string;
+    }, { origin, pathname }: {
+        pathname: string;
+        origin: string;
+    }): Promise<string>;
+    private origin;
+    private pathname;
+    private params;
+    private token;
+    private headers;
+    constructor(options: EntityRequest<{
+        origin: string;
+        pathname: string;
+        token?: string;
+    }>);
+    private getAuthorizedHeaders;
+    private populateFromSchema;
+    getSingle<S extends Schema>(pluralID: string, options: EntityRequest<{
+        schema: S;
+        populate?: any;
+    }>): Promise<{
+        data: InferSchema<S>;
+        meta: any;
+    }>;
+    getSingle(pluralID: string, options: EntityRequest<{
+        populate?: any;
+    }>): Promise<{
+        data: any;
+        meta: any;
+    }>;
+    getCollection<S extends Schema>(pluralID: string, options: EntityRequest<{
+        schema: S;
+        pagination?: false | {
+            page?: number;
+            pageSize?: number;
+        };
+        populate?: any;
+    }>): Promise<{
+        data: InferSchema<S>[];
+        meta: any;
+    }>;
+    getCollection(pluralID: string, options: EntityRequest<{
+        pagination?: false | {
+            page?: number;
+            pageSize?: number;
+        };
+        populate?: any;
+    }>): Promise<{
+        data: any[];
+        meta: any;
+    }>;
+}
+export default Client;

package/dist/client.js

@@ -0,0 +1,267 @@
+import { createSimpleException, isSimpleExceptionOrFallback } from "@hund-ernesto/simple-exception";
+import { join } from "path";
+import fetch from "node-fetch";
+import qs from "qs";
+import z from "zod";
+import { schemaToParser } from "./utils/schema";
+class Client {
+    static async create(endpoint, { auth, ...options } = {}) {
+        const endpointURL = new URL(endpoint);
+        const origin = endpointURL.origin;
+        const pathname = endpointURL.pathname;
+        let token;
+        if (auth) {
+            if (typeof auth === "object") {
+                token = await Client.getToken(auth, { origin, pathname });
+            }
+            else {
+                token = auth;
+            }
+        }
+        return new Client({ origin, pathname, ...options, token });
+    }
+    static getRequestURL({ pathname, origin, params, }) {
+        const endpointURL = new URL(pathname, origin);
+        const queryString = qs.stringify(params, { arrayFormat: "brackets", encodeValuesOnly: true });
+        endpointURL.search = queryString;
+        return endpointURL;
+    }
+    static async getToken(auth, { origin, pathname }) {
+        try {
+            const requestURL = this.getRequestURL({
+                pathname: join(pathname, "/auth/local"),
+                origin,
+            });
+            const response = await fetch(requestURL, {
+                method: "POST",
+                headers: this.headers,
+                body: JSON.stringify({ identifier: auth.email, password: auth.password }),
+            });
+            if (!response.ok) {
+                throw createSimpleException({
+                    code: response.status,
+                    message: response.statusText,
+                    type: "error",
+                    source: "strapi-utils/client.ts",
+                });
+            }
+            const data = await response.json();
+            const { token } = z.object({ token: z.string() }).parse(data);
+            return token;
+        }
+        catch (exception) {
+            throw isSimpleExceptionOrFallback(exception);
+        }
+    }
+    constructor(options) {
+        this.options = options;
+        this.params = {};
+        this.token = null;
+        this.headers = {};
+        this.getAuthorizedHeaders = () => {
+            const headers = { ...this.headers };
+            if (this.token)
+                headers.Authorization = `Bearer ${this.token}`;
+            return headers;
+        };
+        this.populateFromSchema = (shape) => {
+            const populateHasManyRelation = ([, shape]) => {
+                return this.populateFromSchema(shape);
+            };
+            const populateComponentSingle = ([, shape]) => {
+                return this.populateFromSchema(shape);
+            };
+            const populateComponentRepeatable = ([, shape]) => {
+                return this.populateFromSchema(shape);
+            };
+            const populateDynamic = ([, shape]) => {
+                const blocks = {};
+                for (const [key, field] of Object.entries(shape)) {
+                    blocks[key] = { populate: this.populateFromSchema(field) };
+                    if (!Object.keys(blocks[key].populate)["length"])
+                        blocks[key] = true;
+                }
+                return blocks;
+            };
+            const populate = {};
+            for (const [key, field] of Object.entries(shape)) {
+                switch (field[0]) {
+                    case "relation.hasMany":
+                        populate[key] = { populate: populateHasManyRelation(field) };
+                        if (!Object.keys(populate[key].populate)["length"])
+                            populate[key] = true;
+                        break;
+                    case "component.single":
+                        populate[key] = { populate: populateComponentSingle(field) };
+                        if (!Object.keys(populate[key].populate)["length"])
+                            populate[key] = true;
+                        break;
+                    case "component.repeatable":
+                        populate[key] = { populate: populateComponentRepeatable(field) };
+                        if (!Object.keys(populate[key].populate)["length"])
+                            populate[key] = true;
+                        break;
+                    case "media.single":
+                        populate[key] = { populate: true };
+                        break;
+                    case "dynamic":
+                        populate[key] = { on: populateDynamic(field) };
+                        break;
+                }
+            }
+            return populate;
+        };
+        const headers = (() => {
+            return { ...Client.headers, ...(this.options.headers || {}) };
+        })();
+        const params = (() => {
+            return this.options.params || this.params;
+        })();
+        const token = (() => {
+            return this.options.token || null;
+        })();
+        this.origin = this.options.origin;
+        this.pathname = this.options.pathname;
+        this.params = params;
+        this.headers = headers;
+        this.token = token;
+    }
+    async getSingle(pluralID, { params = {}, headers = {}, ...options } = {}) {
+        try {
+            if ("schema" in options) {
+                const { schema } = options;
+                if (schema) {
+                    params.populate = this.populateFromSchema(schema);
+                    if ("populate" in options) {
+                        if (!!options.populate)
+                            console.warn("⚠️ Since you provided both the 'populate' and 'schema', the 'populate' parameter will be ignored.");
+                    }
+                }
+            }
+            else if ("populate" in options) {
+                params.populate = options.populate;
+            }
+            const requestURL = Client.getRequestURL({
+                origin: this.origin,
+                pathname: join(this.pathname, pluralID),
+                params,
+            });
+            const response = await fetch(requestURL, {
+                method: "GET",
+                headers: {
+                    ...this.getAuthorizedHeaders(),
+                    ...headers,
+                },
+            });
+            if (!response.ok) {
+                throw createSimpleException({
+                    code: response.status,
+                    message: response.statusText,
+                    type: "error",
+                    source: "strapi-utils/client.ts",
+                });
+            }
+            const { data: [data], meta, } = z.object({ data: z.array(z.any()), meta: z.any() }).parse(await response.json());
+            if (!data)
+                throw createSimpleException({ code: 404, type: "error", message: "Not found" });
+            if ("schema" in options) {
+                const { schema: shape } = options;
+                if (shape) {
+                    const schema = z.object(schemaToParser(shape)).loose();
+                    const result = schema.safeParse(data);
+                    if (!result.success) {
+                        console.warn("⚠️ Single entity parsing error");
+                        console.error("🚨 Error", result.error);
+                        return { data: null, meta };
+                    }
+                    return { data: result.data, meta };
+                }
+            }
+            return { data, meta };
+        }
+        catch (exception) {
+            throw isSimpleExceptionOrFallback(exception);
+        }
+    }
+    async getCollection(pluralID, { params = {}, headers = {}, pagination = { page: 1 }, ...options } = {}) {
+        try {
+            if ("schema" in options) {
+                const { schema } = options;
+                if (schema) {
+                    params.populate = this.populateFromSchema(schema);
+                    if ("populate" in options) {
+                        if (!!options.populate)
+                            console.warn("⚠️ Since you provided both the 'populate' adnd 'schema', the 'populate' parameter will be ignored.");
+                    }
+                }
+            }
+            else if ("populate" in options) {
+                params.populate = options.populate;
+            }
+            const fetchPage = async (page = 1, acc = []) => {
+                params.pagination = { page, pageSize: 100 };
+                if (pagination)
+                    params.pagination = { ...params.pagination, ...pagination };
+                const requestURL = Client.getRequestURL({
+                    origin: this.origin,
+                    pathname: join(this.pathname, pluralID),
+                    params,
+                });
+                const response = await fetch(requestURL, {
+                    method: "GET",
+                    headers: {
+                        ...this.getAuthorizedHeaders(),
+                        ...headers,
+                    },
+                });
+                if (!response.ok) {
+                    throw createSimpleException({
+                        code: response.status,
+                        message: response.statusText,
+                        type: "error",
+                        source: "strapi-utils/client.ts",
+                    });
+                }
+                const { data, meta } = z
+                    .object({ data: z.array(z.any()).catch([]), meta: z.any() })
+                    .parse(await response.json());
+                const accData = [...acc, ...data];
+                if (!pagination) {
+                    if (meta.pagination?.page < meta.pagination?.pageCount) {
+                        return await fetchPage(meta.pagination.page + 1, accData);
+                    }
+                }
+                return { data: accData, meta };
+            };
+            const { data, meta } = await fetchPage();
+            if ("schema" in options) {
+                const { schema: shape } = options;
+                if (shape) {
+                    const schema = z.object(schemaToParser(shape)).loose();
+                    const parsedData = [];
+                    for (const entry of data) {
+                        const result = schema.safeParse(entry);
+                        if (result.success) {
+                            parsedData.push(result.data);
+                        }
+                        else {
+                            console.warn("⚠️ Collection parsing error on entry");
+                            console.error("🚨 Error", result.error);
+                        }
+                    }
+                    return { data: parsedData, meta };
+                }
+            }
+            return { data, meta };
+        }
+        catch (exception) {
+            throw isSimpleExceptionOrFallback(exception);
+        }
+    }
+}
+// #region STATIC
+Client.headers = {
+    accept: "application/json",
+    "Content-Type": "application/json",
+};
+export default Client;

package/dist/fields/component.d.ts

@@ -0,0 +1,28 @@
+import { ZodType } from "zod";
+import { InferSchema, Schema } from "../client";
+/**
+ * SINGLE
+ */
+export type ComponentSingleOptions = {
+    required?: boolean;
+};
+export type InferComponentSingle<S extends Schema, O extends ComponentSingleOptions> = O["required"] extends true ? InferSchema<S> : InferSchema<S> | null | undefined;
+export declare const singleSchema: (shape: Schema, opts: ComponentSingleOptions) => ZodType;
+export type ComponentSingleField = readonly ["component.single", Schema, ComponentSingleOptions];
+/**
+ * REPEATABLE
+ */
+export type ComponentRepeatableOptions = {
+    required?: boolean;
+};
+export type InferComponentRepeatable<S extends Schema, O extends ComponentRepeatableOptions> = O["required"] extends true ? InferSchema<S>[] : InferSchema<S>[] | null | undefined;
+export declare const repeatableSchema: (shape: Schema, opts: ComponentRepeatableOptions) => ZodType;
+export type ComponentRepeatableField = readonly [
+    "component.repeatable",
+    Schema,
+    ComponentRepeatableOptions
+];
+export declare const component: {
+    single: <S = any, O extends ComponentSingleOptions = {}>(shape: S, options?: O) => ["component.single", S, O];
+    repeatable: <S = any, O extends ComponentRepeatableOptions = {}>(shape: S, options?: O) => ["component.repeatable", S, O];
+};

package/dist/fields/component.js

@@ -0,0 +1,25 @@
+import z from "zod";
+import { schemaToParser } from "../utils/schema";
+const single = (shape, options = {}) => {
+    return ["component.single", shape, options];
+};
+export const singleSchema = (shape, opts) => {
+    let schema = z.object(schemaToParser(shape));
+    // if (opts.nullable) schema = schema.nullable();
+    // if (opts.optional) schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};
+const repeatable = (shape, options = {}) => {
+    return ["component.repeatable", shape, options];
+};
+export const repeatableSchema = (shape, opts) => {
+    let schema = z.array(z.object(schemaToParser(shape)));
+    // if (opts.nullable) schema = schema.nullable();
+    // if (opts.optional) schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};
+export const component = { single, repeatable };

package/dist/fields/dynamic.d.ts

@@ -0,0 +1,16 @@
+import { InferSchema, Schema } from "../client";
+import { ZodType } from "zod";
+export type DynamicOptions = {
+    nullable?: boolean;
+    optional?: boolean;
+};
+type DynamicBlocksUnion<B extends Record<string, Schema>> = {
+    [K in keyof B]: {
+        __component: K;
+    } & InferSchema<B[K]>;
+}[keyof B];
+export type InferDynamic<B extends Record<string, Schema>, O extends DynamicOptions> = O["nullable"] extends true ? O["optional"] extends true ? DynamicBlocksUnion<B>[] | null | undefined : DynamicBlocksUnion<B>[] | null : O["optional"] extends true ? DynamicBlocksUnion<B>[] | undefined : DynamicBlocksUnion<B>[];
+export declare const dynamic: <B extends Record<string, Schema>, O extends DynamicOptions = {}>(blocks: B, options?: O) => ["dynamic", B, O];
+export declare const dynamicSchema: (blocks: Record<string, Schema>, opts: DynamicOptions) => ZodType;
+export type DynamicField = readonly ["dynamic", Record<string, Schema>, DynamicOptions];
+export {};

package/dist/fields/dynamic.js

@@ -0,0 +1,20 @@
+import { schemaToParser } from "../utils/schema";
+import z from "zod";
+export const dynamic = (blocks, options = {}) => {
+    return ["dynamic", blocks, options];
+};
+export const dynamicSchema = (blocks, opts) => {
+    const union = Object.entries(blocks).reduce((acc, [key, fields]) => {
+        const block = { __component: z.literal(key), ...schemaToParser(fields) };
+        acc.push(z.object(block));
+        return acc;
+    }, []);
+    if (!union["length"])
+        return z.any();
+    let schema = z.array(z.discriminatedUnion("__component", union));
+    if (opts.nullable)
+        schema = schema.nullable();
+    if (opts.optional)
+        schema = schema.optional();
+    return schema;
+};

package/dist/fields/enumeration.d.ts

@@ -0,0 +1,8 @@
+import { ZodType } from "zod";
+export type EnumerationOptions = {
+    required?: boolean;
+};
+export type InferEnumeration<V extends readonly [string, ...string[]], O extends EnumerationOptions> = O["required"] extends true ? V[number] : V[number] | null | undefined;
+export declare const enumeration: <Values extends readonly [string, ...string[]], O extends EnumerationOptions = {}>(values: Values, options?: O) => ["enumeration", Values, O];
+export declare const enumerationSchema: (values: readonly [string, ...string[]], opts: EnumerationOptions) => ZodType;
+export type EnumerationField = ReturnType<typeof enumeration>;

package/dist/fields/enumeration.js

@@ -0,0 +1,12 @@
+import z from "zod";
+export const enumeration = (values, options = {}) => {
+    return ["enumeration", values, options];
+};
+export const enumerationSchema = (values, opts) => {
+    let schema = z.enum([...values]);
+    // if (options.nullable) schema = schema.nullable();
+    // if (options.optional) schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};

package/dist/fields/media.d.ts

@@ -0,0 +1,41 @@
+import z, { ZodType } from "zod";
+export declare const zodMediaSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    alternativeText: z.ZodNullable<z.ZodString>;
+    caption: z.ZodNullable<z.ZodString>;
+    width: z.ZodNullable<z.ZodNumber>;
+    height: z.ZodNullable<z.ZodNumber>;
+    formats: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        hash: z.ZodOptional<z.ZodString>;
+        ext: z.ZodOptional<z.ZodString>;
+        mime: z.ZodString;
+        path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        size: z.ZodNumber;
+        url: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>>;
+    hash: z.ZodString;
+    ext: z.ZodString;
+    mime: z.ZodString;
+    size: z.ZodNumber;
+    url: z.ZodString;
+    previewUrl: z.ZodNullable<z.ZodString>;
+    provider: z.ZodString;
+    provider_metadata: z.ZodNullable<z.ZodUnknown>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+type ZodMediaType = z.output<typeof zodMediaSchema>;
+export type MediaSingleOptions = {
+    required?: boolean;
+};
+export type InferMediaSingle<O extends MediaSingleOptions> = O["required"] extends true ? ZodMediaType : ZodMediaType | null | undefined;
+export declare const mediaSingleSchema: (opts: MediaSingleOptions) => ZodType;
+export type MediaSingleField = readonly ["media.single", MediaSingleOptions];
+export declare const media: {
+    single: <O extends MediaSingleOptions = {}>(options?: O) => ["media.single", O];
+};
+export {};

package/dist/fields/media.js

@@ -0,0 +1,44 @@
+import z from "zod";
+export const zodMediaSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    alternativeText: z.string().nullable(),
+    caption: z.string().nullable(),
+    width: z.number().nullable(),
+    height: z.number().nullable(),
+    formats: z
+        .record(z.string(), z.object({
+        name: z.string(),
+        hash: z.string().optional(),
+        ext: z.string().optional(),
+        mime: z.string(),
+        path: z.string().nullable().optional(),
+        size: z.number(),
+        url: z.string(),
+        width: z.number(),
+        height: z.number(),
+    }))
+        .optional(),
+    hash: z.string(),
+    ext: z.string(),
+    mime: z.string(),
+    size: z.number(),
+    url: z.string(),
+    previewUrl: z.string().nullable(),
+    provider: z.string(),
+    provider_metadata: z.unknown().nullable(),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+});
+const single = (options = {}) => {
+    return ["media.single", options];
+};
+export const mediaSingleSchema = (opts) => {
+    let schema = zodMediaSchema;
+    // if (opts.nullable) schema = schema.nullable();
+    // if (opts.optional) schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};
+export const media = { single };

package/dist/fields/number.d.ts

@@ -0,0 +1,9 @@
+import { ZodType } from "zod";
+export type NumberOptions = {
+    nullable?: boolean;
+    optional?: boolean;
+};
+export type InferNumber<O extends NumberOptions> = O["nullable"] extends true ? O["optional"] extends true ? number | null | undefined : number | null : O["optional"] extends true ? number | undefined : number;
+export declare const number: <O extends NumberOptions = {}>(options?: O) => ["number", O];
+export declare const numberSchema: (opts: NumberOptions) => ZodType;
+export type NumberField = ReturnType<typeof number>;

package/dist/fields/number.js

@@ -0,0 +1,12 @@
+import z from "zod";
+export const number = (options = {}) => {
+    return ["number", options];
+};
+export const numberSchema = (opts) => {
+    let schema = z.number();
+    if (opts.nullable)
+        schema = schema.nullable();
+    if (opts.optional)
+        schema = schema.optional();
+    return schema;
+};

package/dist/fields/relation.d.ts

@@ -0,0 +1,10 @@
+import { InferSchema, Schema } from "../client";
+export type RelationHasManyOptions = {
+    nullable?: boolean;
+    optional?: boolean;
+};
+export type InferRelationHasMany<S extends Schema, O extends RelationHasManyOptions> = O["nullable"] extends true ? O["optional"] extends true ? InferSchema<S>[] | null | undefined : InferSchema<S>[] | null : O["optional"] extends true ? InferSchema<S>[] | undefined : InferSchema<S>[];
+export type RelationHasManyField = readonly ["relation.hasMany", Schema, RelationHasManyOptions];
+export declare const relation: {
+    hasMany: <S = any, O extends RelationHasManyOptions = {}>(shape: S, options?: O) => ["relation.hasMany", S, O];
+};

package/dist/fields/relation.js

@@ -0,0 +1,4 @@
+const hasMany = (shape, options = {}) => {
+    return ["relation.hasMany", shape, options];
+};
+export const relation = { hasMany };

package/dist/fields/richText.d.ts

@@ -0,0 +1,32 @@
+import z, { ZodType } from "zod";
+type TextChild = {
+    type: "text";
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    code?: boolean;
+};
+type LinkChild = {
+    type: "link";
+    url: string;
+    children: ParagraphChild[];
+};
+export type ParagraphChild = TextChild | LinkChild;
+export declare const paragraphChild: z.ZodType<ParagraphChild>;
+export declare const zodRichTextBlocksSchema: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"paragraph">;
+    children: z.ZodArray<z.ZodType<ParagraphChild, unknown, z.core.$ZodTypeInternals<ParagraphChild, unknown>>>;
+}, z.core.$strip>]>>;
+type ZodRichTextBlocksType = z.output<typeof zodRichTextBlocksSchema>;
+export type RichTextBlocksOptions = {
+    required?: boolean;
+};
+export type InferRichTextBlocks<O extends RichTextBlocksOptions> = O["required"] extends true ? ZodRichTextBlocksType : ZodRichTextBlocksType | null | undefined;
+export declare const richTextBlocksSchema: (opts: RichTextBlocksOptions) => ZodType;
+export type RichTextBlocksField = readonly ["richText.blocks", RichTextBlocksOptions];
+export declare const richText: {
+    blocks: <O extends RichTextBlocksOptions = {}>(options?: O) => ["richText.blocks", O];
+};
+export {};

package/dist/fields/richText.js

@@ -0,0 +1,34 @@
+import z from "zod";
+export const paragraphChild = z.lazy(() => z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+        bold: z.boolean().optional(),
+        italic: z.boolean().optional(),
+        underline: z.boolean().optional(),
+        strikethrough: z.boolean().optional(),
+        code: z.boolean().optional(),
+    }),
+    z.object({
+        type: z.literal("link"),
+        url: z.string(),
+        children: z.array(paragraphChild),
+    }),
+]));
+const paragraphBlock = z.object({
+    type: z.literal("paragraph"),
+    children: z.array(paragraphChild),
+});
+export const zodRichTextBlocksSchema = z.array(z.union([paragraphBlock]));
+const blocks = (options = {}) => {
+    return ["richText.blocks", options];
+};
+export const richTextBlocksSchema = (opts) => {
+    let schema = zodRichTextBlocksSchema;
+    // if (opts.nullable) schema = schema.nullable();
+    // if (opts.optional) schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};
+export const richText = { blocks };

package/dist/fields/text.d.ts

@@ -0,0 +1,8 @@
+import { ZodType } from "zod";
+export type TextOptions = {
+    required?: boolean;
+};
+export type InferText<O extends TextOptions> = O["required"] extends true ? string : string | null | undefined;
+export declare const text: <O extends TextOptions = {}>(options?: O) => ["text", O];
+export declare const textSchema: (opts: TextOptions) => ZodType;
+export type TextField = ReturnType<typeof text>;

package/dist/fields/text.js

@@ -0,0 +1,12 @@
+import z from "zod";
+export const text = (options = {}) => {
+    return ["text", options];
+};
+export const textSchema = (opts) => {
+    let schema = z.string();
+    // if (opts.nullable) schema = schema.nullable();
+    // if (opts.optional) schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { default as StrapiClient } from "./client";
+export * from "./fields/text";
+export * from "./fields/number";
+export * from "./fields/relation";
+export * from "./fields/dynamic";
+export * from "./fields/component";
+export * from "./fields/media";
+export * from "./fields/enumeration";
+export * from "./fields/richText";

package/dist/index.js

@@ -0,0 +1,9 @@
+export { default as StrapiClient } from "./client";
+export * from "./fields/text";
+export * from "./fields/number";
+export * from "./fields/relation";
+export * from "./fields/dynamic";
+export * from "./fields/component";
+export * from "./fields/media";
+export * from "./fields/enumeration";
+export * from "./fields/richText";

package/dist/utils/schema.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "../client";
+import z from "zod";
+export declare const schemaToParser: (schema: Schema) => Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;

package/dist/utils/schema.js

@@ -0,0 +1,59 @@
+import { dynamicSchema } from "../fields/dynamic";
+import { mediaSingleSchema } from "../fields/media";
+import { numberSchema } from "../fields/number";
+import { repeatableSchema, singleSchema } from "../fields/component";
+import { textSchema } from "../fields/text";
+import z from "zod";
+import { enumerationSchema } from "../fields/enumeration";
+import { richTextBlocksSchema } from "../fields/richText";
+export const schemaToParser = (schema) => {
+    const shape = {};
+    for (const [key, field] of Object.entries(schema)) {
+        switch (field[0]) {
+            case "text": {
+                const [, args] = field;
+                shape[key] = textSchema(args);
+                break;
+            }
+            case "number": {
+                const [, args] = field;
+                shape[key] = numberSchema(args);
+                break;
+            }
+            case "dynamic": {
+                const [, ...args] = field;
+                shape[key] = dynamicSchema(...args);
+                break;
+            }
+            case "component.single": {
+                const [, shapeDef, options] = field;
+                shape[key] = singleSchema(shapeDef, options);
+                break;
+            }
+            case "component.repeatable": {
+                const [, shapeDef, options] = field;
+                shape[key] = repeatableSchema(shapeDef, options);
+                break;
+            }
+            case "media.single": {
+                const [, args] = field;
+                shape[key] = mediaSingleSchema(args);
+                break;
+            }
+            case "enumeration": {
+                const [, values, options] = field;
+                shape[key] = enumerationSchema(values, options);
+                break;
+            }
+            case "richText.blocks": {
+                const [, args] = field;
+                shape[key] = richTextBlocksSchema(args);
+                break;
+            }
+            default: {
+                shape[key] = z.any();
+            }
+        }
+    }
+    return shape;
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "simple-strapi",
+  "version": "1.0.0-alpha.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "readme": "docs/NPM.md",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hund-studio/simple-strapi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hund-studio/simple-strapi/issues"
+  },
+  "homepage": "https://github.com/hund-studio/simple-strapi#readme",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "publish:prerelease": "tsx scripts/publish.ts prerelease alpha",
+    "publish:prepatch": "tsx scripts/publish.ts prepatch alpha",
+    "publish:patch": "tsx scripts/publish.ts patch",
+    "publish:preminor": "tsx scripts/publish.ts preminor alpha",
+    "publish:minor": "tsx scripts/publish.ts minor",
+    "publish:premajor": "tsx scripts/publish.ts premajor alpha",
+    "publish:major": "tsx scripts/publish.ts major",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "node-fetch": "^3.3.2",
+    "qs": "^6.14.0",
+    "simple-exception": "^1.0.0-alpha.1",
+    "zod": "^4.0.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.14",
+    "@types/qs": "^6.14.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.0.0"
+  }
+}