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

package/dist/client.d.ts

@@ -1,7 +1,9 @@
 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";
@@ -11,7 +13,7 @@ type EntityRequest<P = {}> = {
     params?: RequestParams;
     headers?: Record<string, string>;
 } & P;
-export type SchemaField = TextField | NumberField | RelationHasManyField | DynamicField | ComponentSingleField | ComponentRepeatableField | MediaSingleField | EnumerationField | RichTextBlocksField;
+export type SchemaField = TextField | NumberField | RelationHasManyField | RelationHasOneField | 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 [
@@ -19,6 +21,10 @@ export type InferSchema<S extends Schema> = {
         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 +42,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 +76,7 @@ declare class Client {
         schema: S;
         populate?: any;
     }>): Promise<{
-        data: InferSchema<S>;
+        data: InferSchemaWithDefaults<S>;
         meta: any;
     }>;
     getSingle(pluralID: string, options: EntityRequest<{
@@ -86,7 +93,7 @@ declare class Client {
         };
         populate?: any;
     }>): Promise<{
-        data: InferSchema<S>[];
+        data: InferSchemaWithDefaults<S>[];
         meta: any;
     }>;
     getCollection(pluralID: string, options: EntityRequest<{

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 } = {}) {
@@ -237,7 +247,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 +255,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 +265,7 @@ class Client {
             return { data, meta };
         }
         catch (exception) {
-            throw isSimpleExceptionOrFallback(exception);
+            throw ensureSimpleException(exception);
         }
     }
 }

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/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/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

@@ -6,6 +6,14 @@ import { textSchema } from "../fields/text";
 import z from "zod";
 import { enumerationSchema } from "../fields/enumeration";
 import { richTextBlocksSchema } from "../fields/richText";
+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)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-strapi",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",