What did you implement

• typings of custom fields

How can I test it?

• symbolic link repository to node_modules of your plugin/server
• types are present on IStrapi

What did you implement

• duplicates removed
• less restrictive OR and AND query statements

How can I test it?

declare const foo: StrapiDBQuery<{ test: string, notRequired: string }> ;

foo.findMany({
    where: {
        $or: [
            { test: { $startsWith: "F" } },
            {
                test: "FOO",
            }
        ] 
        
    }
})

Should be valid

Fixes issue for constructions like:

   strapi.db
      .query<CommentReport>(getModelUid("comment-report"))
      .updateMany({
        where: {
          $and: [
            { id: ids },
            { related: commentId }
          ]
        },
        data: { resolved: true },
      });

Causing error like

Type '{ id: Id[]; }' is missing the following properties from type 'Record<keyof CommentReport, WhereOperator<Primitive>>': related, content, reason, resolved

That was because $and / $or weren't defined as Partial<Record<...>>

Aligns createMany, updateMany, deleteMany response to the Strapi docs:

https://docs.strapi.io/developer-docs/latest/developer-resources/database-apis-reference/query-engine/bulk-operations.html#createmany

What did you implement

• extend typings of strapi controller

How can I test it?

• describe a controller with new typings
• provide generic type arguments
• controller should have context provided (now with error constructors)

Let populate work by three different and supported ways:

• boolean like populate: true
• array like populate: ['field1', 'field2']
• object with field names of query type (nested) like:

  {
     field: {
         nestedField: { ... }
     }
  }
  

And introduce the select property to DB query.

What did you implement

• typings for strapi's content type definition

How can I test it?

• define a content type schema like:

export const foo: StrapiContentTypeSchema<
  "firstName" | "lastName" | "age" | "profilePicture" | "friends"
> = {
  attributes: {
    age: {
      type: "integer",
    },
    firstName: {
      type: "string",
      required: true,
    },
    lastName: {
      type: "string",
      required: true,
    },
    friends: {
      type: "relation",
      relation: "manyToMany",
      target: "api::some.other",
    },
    profilePicture: {
      type: "media",
      allowedTypes: ["images", "videos"],
    },
  },
  info: {
    description: "",
    displayName: "Foo",
    pluralName: "Foos",
    singularName: "Foo",
  },
  kind: "collectionType",
  options: {},
};

• check if all specified fields are required (should be)
• check if validation/suggestions change on type specification

Summary

Typings for all parts of strapi core related to webhooks.

Testing

There should be no errors when using the below snippet.

const webhookBody = {
  name: 'test_name',
  type: '',
  url: 'http://localhost:3000',
  headers: {},
  events: [],
  enabled: false,
};

const webhooks = await strapi.webhookStore.findWebhooks();
const webhook = await strapi.webhookStore.findWebhook(1);
const newWebhook = await strapi.webhookStore.createWebhook(webhookBody);
const runResponse = await strapi.webhookRunner.run(webhook, 'trigger-test', {});
strapi.webhookRunner.eventHub.emit('entry.create');

What did you implement?

• typings for DB querying
• minor styling issues
• minor typing improvements (simplification, alternatives)

How it can be tested?

Statement below should be valid and auto-completion should, well, autocomplete as you expand on this example.

type FooUser = {
  firstName: string,
  lastName: string,
  age: number,
}
type Foo = TypeResult<
    WhereClause<keyof FooUser, string | number>
>;
const foo: Foo = {
    firstName: "Lorem",
    lastName: {
        $containsi: "Ipsum",
    },
    $or: [
        {
            firstName: {
                $null: true,
            },
        },
        {
            age: {
                $gt: 9000
            }
        }
    ],
    $and: [
        {
            firstName: "Dull",
            lastName: {
                $notContains: "Boy",
            },
        },
    ],
};

What did you implement

• move of declarations to ambient modules to enable interface merging
• this is a BREAKING CHANGE

How can I test it?

• symbolic link repository to node_modules of your plugin/server
• types are available at @strapi/strapi and @strapi/typed