@brickkit/crud

import { crud } from "@brickkit/crud";

function crud<
  const F extends Fields,
  const O extends Operations = {},
>(
  options: CrudOptions<F, O>,
): CrudPlugin<F, O>

import { crud } from "@brickkit/crud";

export const page = pagesService
  .resource({ name: "page", table: pages, id: pages.id })
  .use(
    crud({
      access: "public",
      fields: {
        id: { read: true, filter: ["eq", "in"] },
        title: { read: true, create: true, update: true, sort: true },
      },
    }),
  );

interface ColumnFieldPolicy

interface CrudOptions<F extends Fields = Fields, O extends Operations = Operations>

interface CrudTypes<F, O>

interface DerivedFieldPolicy

interface Query<T extends Table, F, S extends readonly ReadKeys<T, F>[] | undefined = undefined, I extends readonly IncludeKeys<F>[] | undefined = undefined>

type CrudAPI<T extends Table, C, F, O, ID = Row<T>[keyof Row<T>]> = [
  O,
] extends [false]
  ? {}
  : Pick<
      AllAPI<T, C, F, ID>,
      { [K in Operation]: O extends Record<K, false> ? never : K }[Operation]
    >;

type CrudAuthorizeArgs<F extends Fields = Fields> = {
  [K in Operation]: {
    operation: K;
    input: CrudInputs<F>[K];
    ctx: ActionContext;
  };
}[Operation];

type CrudInputs<F extends Fields = Fields> = {
  list: { [K in keyof AuthorizeQuery<F>]: AuthorizeQuery<F>[K] };
  findOne: { [K in keyof AuthorizeQuery<F>]: AuthorizeQuery<F>[K] };
  get: {
    id: unknown;
    select?: readonly Exclude<AuthorizeKeys<F, "read">, IncludeKeys<F>>[];
    include?: readonly IncludeKeys<F>[];
  };
  create: AuthorizeWrite<F, "create">;
  update: { id: unknown; data: AuthorizeWrite<F, "update"> };
  delete: { id: unknown };
  count: { where?: AuthorizeQuery<F>["where"] };
  exists: { where?: AuthorizeQuery<F>["where"] };
};

type CrudPlugin<F extends Fields, O extends Operations> = ResourcePlugin<
  any,
  any,
  object
> & { readonly types: CrudTypes<F, O> };

type FieldPolicy = ColumnFieldPolicy | DerivedFieldPolicy;

type Fields = Readonly<Record<string, FieldPolicy>>;

type FilterOperator =
  | "eq"
  | "ne"
  | "in"
  | "notIn"
  | "gt"
  | "gte"
  | "lt"
  | "lte"
  | "between"
  | "contains"
  | "startsWith"
  | "endsWith"
  | "isNull"
  | "isNotNull";

type Operation =
  | "list"
  | "get"
  | "create"
  | "update"
  | "delete"
  | "findOne"
  | "count"
  | "exists";

type Operations = false | Partial<Record<Operation, boolean>>;

type ReadRow<T extends Table, F> = {
  [K in ReadKeys<T, F>]: FieldValue<T, F, K>;
};

type Where<T extends Table, F> = FilterWhere<F, Row<T>>;