simple-strapi 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/client.d.ts

@@ -1,24 +1,33 @@
+import { InferBoolean, BooleanField, BooleanOptions } from "./fields/boolean";
 import { InferNumber, NumberField, NumberOptions } from "./fields/number";
 import { InferText, TextField, TextOptions } from "./fields/text";
-import { InferRelationHasMany, RelationHasManyField, RelationHasManyOptions } from "./fields/relation";
+import { InferRelationHasMany, InferRelationHasOne, RelationHasManyField, RelationHasManyOptions, RelationHasOneField, RelationHasOneOptions } from "./fields/relation";
+import z from "zod";
 import { DynamicField, DynamicOptions, InferDynamic } from "./fields/dynamic";
+import { defaultStrapiFieldsSchema } from "./utils/schema";
 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";
+import { InferJSON, JSONField, JSONOptions } from "./fields/json";
 type RequestParams = Record<string, any>;
 type EntityRequest<P = {}> = {
+    where?: Record<string, string>;
     params?: RequestParams;
     headers?: Record<string, string>;
 } & P;
-export type SchemaField = TextField | NumberField | RelationHasManyField | DynamicField | ComponentSingleField | ComponentRepeatableField | MediaSingleField | EnumerationField | RichTextBlocksField;
+export type SchemaField = TextField | NumberField | BooleanField | RelationHasManyField | RelationHasOneField | DynamicField | ComponentSingleField | ComponentRepeatableField | MediaSingleField | EnumerationField | RichTextBlocksField | JSONField;
 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 [
+    [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 ["boolean", infer O extends BooleanOptions] ? InferBoolean<O> : S[K] extends ["json", infer O extends JSONOptions] ? InferJSON<O> : S[K] extends [
         "relation.hasMany",
         infer R extends Schema,
         infer O extends RelationHasManyOptions
     ] ? InferRelationHasMany<R, O> : S[K] extends [
+        "relation.hasOne",
+        infer R extends Schema,
+        infer O extends RelationHasOneOptions
+    ] ? InferRelationHasOne<R, O> : S[K] extends [
         "component.single",
         infer R extends Schema,
         infer O extends ComponentSingleOptions
@@ -36,6 +45,7 @@ export type InferSchema<S extends Schema> = {
         infer O extends EnumerationOptions
     ] ? InferEnumeration<V, O> : S[K] extends ["richText.blocks", infer O extends RichTextBlocksOptions] ? InferRichTextBlocks<O> : never;
 };
+export type InferSchemaWithDefaults<S extends Schema> = InferSchema<S> & z.output<typeof defaultStrapiFieldsSchema>;
 declare class Client {
     private options;
     private static headers;
@@ -69,7 +79,7 @@ declare class Client {
         schema: S;
         populate?: any;
     }>): Promise<{
-        data: InferSchema<S>;
+        data: InferSchemaWithDefaults<S>;
         meta: any;
     }>;
     getSingle(pluralID: string, options: EntityRequest<{
@@ -85,8 +95,9 @@ declare class Client {
             pageSize?: number;
         };
         populate?: any;
+        filters?: Record<string, any>;
     }>): Promise<{
-        data: InferSchema<S>[];
+        data: InferSchemaWithDefaults<S>[];
         meta: any;
     }>;
     getCollection(pluralID: string, options: EntityRequest<{
@@ -95,9 +106,35 @@ declare class Client {
             pageSize?: number;
         };
         populate?: any;
+        filters?: Record<string, any>;
     }>): Promise<{
         data: any[];
         meta: any;
     }>;
+    /**
+     *
+     * WRITE ACTIONS
+     *
+     */
+    update<S extends Schema>(pluralID: string, documentId: string, payload: any, options?: EntityRequest<{
+        schema?: S;
+    }>): Promise<{
+        data: InferSchemaWithDefaults<S>;
+        meta: any;
+    }>;
+    create<S extends Schema>(pluralID: string, payload: any, options?: EntityRequest<{
+        schema?: S;
+    }>): Promise<{
+        data: InferSchemaWithDefaults<S>;
+        meta: any;
+    }>;
+    private writeRequest;
+    /**
+     * Elimina un'entità specifica tramite il suo documentId.
+     */
+    delete(pluralID: string, documentId: string, options?: EntityRequest): Promise<{
+        data: any;
+        meta: any;
+    }>;
 }
 export default Client;

package/dist/client.js

@@ -1,9 +1,9 @@
-import { createSimpleException, isSimpleExceptionOrFallback } from "@hund-ernesto/simple-exception";
+import { createSimpleException, ensureSimpleException } from "simple-exception";
 import { join } from "path";
 import fetch from "node-fetch";
 import qs from "qs";
 import z from "zod";
-import { schemaToParser } from "./utils/schema";
+import { defaultStrapiFields, schemaToParser } from "./utils/schema";
 class Client {
     static async create(endpoint, { auth, ...options } = {}) {
         const endpointURL = new URL(endpoint);
@@ -50,7 +50,7 @@ class Client {
             return token;
         }
         catch (exception) {
-            throw isSimpleExceptionOrFallback(exception);
+            throw ensureSimpleException(exception);
         }
     }
     constructor(options) {
@@ -68,6 +68,9 @@ class Client {
             const populateHasManyRelation = ([, shape]) => {
                 return this.populateFromSchema(shape);
             };
+            const populateHasOneRelation = ([, shape]) => {
+                return this.populateFromSchema(shape);
+            };
             const populateComponentSingle = ([, shape]) => {
                 return this.populateFromSchema(shape);
             };
@@ -91,6 +94,11 @@ class Client {
                         if (!Object.keys(populate[key].populate)["length"])
                             populate[key] = true;
                         break;
+                    case "relation.hasOne":
+                        populate[key] = { populate: populateHasOneRelation(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"])
@@ -161,13 +169,15 @@ class Client {
                     source: "strapi-utils/client.ts",
                 });
             }
-            const { data: [data], meta, } = z.object({ data: z.array(z.any()), meta: z.any() }).parse(await response.json());
+            const { data, meta } = z
+                .object({ data: 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 schema = z.object(schemaToParser(shape)).extend(defaultStrapiFields).loose();
                     const result = schema.safeParse(data);
                     if (!result.success) {
                         console.warn("⚠️ Single entity parsing error");
@@ -180,7 +190,7 @@ class Client {
             return { data, meta };
         }
         catch (exception) {
-            throw isSimpleExceptionOrFallback(exception);
+            throw ensureSimpleException(exception);
         }
     }
     async getCollection(pluralID, { params = {}, headers = {}, pagination = { page: 1 }, ...options } = {}) {
@@ -200,11 +210,12 @@ class Client {
             }
             const fetchPage = async (page = 1, acc = []) => {
                 params.pagination = { page, pageSize: 100 };
+                params.filters = options.filters;
                 if (pagination)
                     params.pagination = { ...params.pagination, ...pagination };
                 const requestURL = Client.getRequestURL({
                     origin: this.origin,
-                    pathname: join(this.pathname, pluralID),
+                    pathname: join(...[this.pathname, pluralID, options.where?.documentId].flatMap((entry) => !!entry ? [entry] : [])),
                     params,
                 });
                 const response = await fetch(requestURL, {
@@ -222,10 +233,12 @@ class Client {
                         source: "strapi-utils/client.ts",
                     });
                 }
+                const responseData = await response.json();
                 const { data, meta } = z
-                    .object({ data: z.array(z.any()).catch([]), meta: z.any() })
-                    .parse(await response.json());
-                const accData = [...acc, ...data];
+                    // .object({ data: z.array(z.any()).catch([]), meta: z.any() })
+                    .object({ data: z.any(), meta: z.any() })
+                    .parse(responseData);
+                const accData = [...acc, ...(Array.isArray(data) ? data : [data])];
                 if (!pagination) {
                     if (meta.pagination?.page < meta.pagination?.pageCount) {
                         return await fetchPage(meta.pagination.page + 1, accData);
@@ -237,7 +250,7 @@ class Client {
             if ("schema" in options) {
                 const { schema: shape } = options;
                 if (shape) {
-                    const schema = z.object(schemaToParser(shape)).loose();
+                    const schema = z.object(schemaToParser(shape)).extend(defaultStrapiFields).loose();
                     const parsedData = [];
                     for (const entry of data) {
                         const result = schema.safeParse(entry);
@@ -245,7 +258,7 @@ class Client {
                             parsedData.push(result.data);
                         }
                         else {
-                            console.warn("⚠️ Collection parsing error on entry");
+                            console.warn("⚠️ Collection parsing error on entry", entry);
                             console.error("🚨 Error", result.error);
                         }
                     }
@@ -255,7 +268,111 @@ class Client {
             return { data, meta };
         }
         catch (exception) {
-            throw isSimpleExceptionOrFallback(exception);
+            throw ensureSimpleException(exception);
+        }
+    }
+    /**
+     *
+     * WRITE ACTIONS
+     *
+     */
+    async update(pluralID, documentId, payload, options = {}) {
+        const path = join(pluralID, documentId);
+        return this.writeRequest("PUT", path, payload, options);
+    }
+    async create(pluralID, payload, options = {}) {
+        return this.writeRequest("POST", pluralID, payload, options);
+    }
+    async writeRequest(method, path, payload, { params = {}, headers = {}, ...options } = {}) {
+        try {
+            if ("schema" in options && options.schema) {
+                params.populate = this.populateFromSchema(options.schema);
+            }
+            const requestURL = Client.getRequestURL({
+                origin: this.origin,
+                pathname: join(this.pathname, path),
+                params,
+            });
+            const response = await fetch(requestURL, {
+                method,
+                headers: {
+                    ...this.getAuthorizedHeaders(),
+                    ...headers,
+                },
+                body: JSON.stringify({ data: payload }),
+            });
+            if (!response.ok) {
+                const errorBody = await response.json().catch(() => ({}));
+                const getErrorMessage = (err) => {
+                    if (err && typeof err === "object" && "error" in err) {
+                        return err.error?.message || response.statusText;
+                    }
+                    return response.statusText;
+                };
+                throw createSimpleException({
+                    code: response.status,
+                    message: getErrorMessage(errorBody),
+                    type: "error",
+                    source: "strapi-utils/client.ts",
+                });
+            }
+            const { data, meta } = z
+                .object({ data: z.any(), meta: z.any() })
+                .parse(await response.json());
+            if ("schema" in options && options.schema) {
+                const shape = options.schema;
+                const schema = z.object(schemaToParser(shape)).extend(defaultStrapiFields).loose();
+                const result = schema.safeParse(data);
+                if (!result.success) {
+                    console.warn(`⚠️ ${method} response parsing error`);
+                    console.error("🚨 Error details:", result.error);
+                    return { data, meta };
+                }
+                return { data: result.data, meta };
+            }
+            return { data, meta };
+        }
+        catch (exception) {
+            throw ensureSimpleException(exception);
+        }
+    }
+    /**
+     * Elimina un'entità specifica tramite il suo documentId.
+     */
+    async delete(pluralID, documentId, options = {}) {
+        try {
+            const { params = {}, headers = {} } = options;
+            const requestURL = Client.getRequestURL({
+                origin: this.origin,
+                pathname: join(this.pathname, pluralID, documentId),
+                params,
+            });
+            const response = await fetch(requestURL, {
+                method: "DELETE",
+                headers: {
+                    ...this.getAuthorizedHeaders(),
+                    ...headers,
+                },
+            });
+            if (!response.ok) {
+                const errorBody = await response.json().catch(() => ({}));
+                throw createSimpleException({
+                    code: response.status,
+                    message: errorBody.error?.message || response.statusText,
+                    type: "error",
+                    source: "strapi-utils/client.ts",
+                });
+            }
+            if (response.status === 204) {
+                return { data: { documentId }, meta: {} };
+            }
+            const { data, meta } = z
+                .object({ data: z.any(), meta: z.any() })
+                .parse(await response.json());
+            return { data, meta };
+        }
+        catch (exception) {
+            throw ensureSimpleException(exception);
         }
     }
 }

package/dist/fields/boolean.d.ts

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

package/dist/fields/boolean.js

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

package/dist/fields/component.d.ts

@@ -1,12 +1,12 @@
 import { ZodType } from "zod";
-import { InferSchema, Schema } from "../client";
+import { InferSchemaWithDefaults, 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 type InferComponentSingle<S extends Schema, O extends ComponentSingleOptions> = O["required"] extends true ? InferSchemaWithDefaults<S> : InferSchemaWithDefaults<S> | null | undefined;
 export declare const singleSchema: (shape: Schema, opts: ComponentSingleOptions) => ZodType;
 export type ComponentSingleField = readonly ["component.single", Schema, ComponentSingleOptions];
 /**
@@ -15,7 +15,7 @@ export type ComponentSingleField = readonly ["component.single", Schema, Compone
 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 type InferComponentRepeatable<S extends Schema, O extends ComponentRepeatableOptions> = O["required"] extends true ? InferSchemaWithDefaults<S>[] : InferSchemaWithDefaults<S>[] | null | undefined;
 export declare const repeatableSchema: (shape: Schema, opts: ComponentRepeatableOptions) => ZodType;
 export type ComponentRepeatableField = readonly [
     "component.repeatable",

package/dist/fields/json.d.ts

@@ -0,0 +1,8 @@
+import { ZodType } from "zod";
+export type JSONOptions = {
+    required?: boolean;
+};
+export type InferJSON<O extends JSONOptions> = O["required"] extends true ? any : any | null | undefined;
+export declare const json: <O extends JSONOptions = {}>(options?: O) => ["json", O];
+export declare const jsonSchema: (opts: JSONOptions) => ZodType;
+export type JSONField = ReturnType<typeof json>;

package/dist/fields/json.js

@@ -0,0 +1,10 @@
+import z from "zod";
+export const json = (options = {}) => {
+    return ["json", options];
+};
+export const jsonSchema = (opts) => {
+    let schema = z.any();
+    if (!opts.required)
+        schema = schema.nullable().optional();
+    return schema;
+};

package/dist/fields/number.d.ts

@@ -1,9 +1,8 @@
 import { ZodType } from "zod";
 export type NumberOptions = {
-    nullable?: boolean;
-    optional?: boolean;
+    required?: 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 type InferNumber<O extends NumberOptions> = O["required"] extends true ? number : number | null | undefined;
 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

@@ -4,9 +4,7 @@ export const number = (options = {}) => {
 };
 export const numberSchema = (opts) => {
     let schema = z.number();
-    if (opts.nullable)
-        schema = schema.nullable();
-    if (opts.optional)
-        schema = schema.optional();
+    if (!opts.required)
+        schema = schema.nullable().optional();
     return schema;
 };

package/dist/fields/relation.d.ts

@@ -1,10 +1,23 @@
-import { InferSchema, Schema } from "../client";
+import { InferSchemaWithDefaults, Schema } from "../client";
+/**
+ * HAS MANY
+ */
 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 InferRelationHasMany<S extends Schema, O extends RelationHasManyOptions> = O["nullable"] extends true ? O["optional"] extends true ? InferSchemaWithDefaults<S>[] | null | undefined : InferSchemaWithDefaults<S>[] | null : O["optional"] extends true ? InferSchemaWithDefaults<S>[] | undefined : InferSchemaWithDefaults<S>[];
 export type RelationHasManyField = readonly ["relation.hasMany", Schema, RelationHasManyOptions];
+/**
+ * HAS ONE
+ */
+export type RelationHasOneOptions = {
+    nullable?: boolean;
+    optional?: boolean;
+};
+export type InferRelationHasOne<S extends Schema, O extends RelationHasOneOptions> = O["nullable"] extends true ? O["optional"] extends true ? InferSchemaWithDefaults<S> | null | undefined : InferSchemaWithDefaults<S> | null : O["optional"] extends true ? InferSchemaWithDefaults<S> | undefined : InferSchemaWithDefaults<S>;
+export type RelationHasOneField = readonly ["relation.hasOne", Schema, RelationHasOneOptions];
 export declare const relation: {
     hasMany: <S = any, O extends RelationHasManyOptions = {}>(shape: S, options?: O) => ["relation.hasMany", S, O];
+    hasOne: <S = any, O extends RelationHasOneOptions = {}>(shape: S, options?: O) => ["relation.hasOne", S, O];
 };

package/dist/fields/relation.js

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

package/dist/fields/richText.d.ts

@@ -18,8 +18,23 @@ 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>, z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodNumber;
+    children: z.ZodArray<z.ZodType<ParagraphChild, unknown, z.core.$ZodTypeInternals<ParagraphChild, unknown>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"list">;
+    format: z.ZodEnum<{
+        ordered: "ordered";
+        unordered: "unordered";
+    }>;
+    children: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"list-item">;
+        children: z.ZodArray<z.ZodType<ParagraphChild, unknown, z.core.$ZodTypeInternals<ParagraphChild, unknown>>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>]>>;
 type ZodRichTextBlocksType = z.output<typeof zodRichTextBlocksSchema>;
+export type RichTextBlocks = ZodRichTextBlocksType;
 export type RichTextBlocksOptions = {
     required?: boolean;
 };

package/dist/fields/richText.js

@@ -19,7 +19,21 @@ const paragraphBlock = z.object({
     type: z.literal("paragraph"),
     children: z.array(paragraphChild),
 });
-export const zodRichTextBlocksSchema = z.array(z.union([paragraphBlock]));
+const headingBlock = z.object({
+    type: z.literal("heading"),
+    level: z.number(),
+    children: z.array(paragraphChild),
+});
+const listItemBlock = z.object({
+    type: z.literal("list-item"),
+    children: z.array(paragraphChild),
+});
+const listBlock = z.object({
+    type: z.literal("list"),
+    format: z.enum(["ordered", "unordered"]),
+    children: z.array(listItemBlock),
+});
+export const zodRichTextBlocksSchema = z.array(z.union([paragraphBlock, headingBlock, listBlock]));
 const blocks = (options = {}) => {
     return ["richText.blocks", options];
 };

package/dist/index.d.ts

@@ -7,3 +7,5 @@ export * from "./fields/component";
 export * from "./fields/media";
 export * from "./fields/enumeration";
 export * from "./fields/richText";
+export * from "./fields/boolean";
+export * from "./fields/json";

package/dist/index.js

@@ -7,3 +7,5 @@ export * from "./fields/component";
 export * from "./fields/media";
 export * from "./fields/enumeration";
 export * from "./fields/richText";
+export * from "./fields/boolean";
+export * from "./fields/json";

package/dist/utils/schema.d.ts

@@ -1,3 +1,17 @@
 import { Schema } from "../client";
 import z from "zod";
+export declare const defaultStrapiFields: {
+    id: z.ZodNumber;
+    documentId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    publishedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+};
+export declare const defaultStrapiFieldsSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    documentId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    publishedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+}, z.core.$strip>;
 export declare const schemaToParser: (schema: Schema) => Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;

package/dist/utils/schema.js

@@ -1,11 +1,21 @@
+import { booleanSchema } from "../fields/boolean";
 import { dynamicSchema } from "../fields/dynamic";
+import { enumerationSchema } from "../fields/enumeration";
 import { mediaSingleSchema } from "../fields/media";
 import { numberSchema } from "../fields/number";
 import { repeatableSchema, singleSchema } from "../fields/component";
+import { richTextBlocksSchema } from "../fields/richText";
 import { textSchema } from "../fields/text";
 import z from "zod";
-import { enumerationSchema } from "../fields/enumeration";
-import { richTextBlocksSchema } from "../fields/richText";
+import { jsonSchema } from "../fields/json";
+export const defaultStrapiFields = {
+    id: z.number(),
+    documentId: z.string().optional(),
+    createdAt: z.iso.datetime().optional(),
+    updatedAt: z.iso.datetime().optional(),
+    publishedAt: z.iso.datetime().nullable().optional(),
+};
+export const defaultStrapiFieldsSchema = z.object(defaultStrapiFields);
 export const schemaToParser = (schema) => {
     const shape = {};
     for (const [key, field] of Object.entries(schema)) {
@@ -20,6 +30,16 @@ export const schemaToParser = (schema) => {
                 shape[key] = numberSchema(args);
                 break;
             }
+            case "json": {
+                const [, args] = field;
+                shape[key] = jsonSchema(args);
+                break;
+            }
+            case "boolean": {
+                const [, args] = field;
+                shape[key] = booleanSchema(args);
+                break;
+            }
             case "dynamic": {
                 const [, ...args] = field;
                 shape[key] = dynamicSchema(...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-strapi",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.21",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -43,7 +43,7 @@
   "dependencies": {
     "node-fetch": "^3.3.2",
     "qs": "^6.14.0",
-    "simple-exception": "^1.0.0-alpha.2",
+    "simple-exception": "github:hund-studio/simple-exception",
     "zod": "^4.0.5"
   },
   "devDependencies": {