prisma-guard 1.3.0 → 1.4.0

package/dist/runtime/index.d.cts

@@ -49,11 +49,12 @@ type ModelOpts = {
 });
 type QueryMethod = 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'count' | 'aggregate' | 'groupBy';
 type MutationMethod = 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany';
+type OrderByFieldConfig = true | Record<string, true>;
 interface ShapeConfig {
     where?: Record<string, unknown>;
     include?: Record<string, true | NestedIncludeArgs>;
     select?: Record<string, true | NestedSelectArgs>;
-    orderBy?: Record<string, true>;
+    orderBy?: Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;
@@ -73,7 +74,7 @@ interface NestedIncludeArgs {
     where?: Record<string, unknown>;
     include?: Record<string, true | NestedIncludeArgs>;
     select?: Record<string, true | NestedSelectArgs>;
-    orderBy?: Record<string, true>;
+    orderBy?: Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;
@@ -84,7 +85,7 @@ interface NestedIncludeArgs {
 interface NestedSelectArgs {
     select?: Record<string, true | NestedSelectArgs>;
     where?: Record<string, unknown>;
-    orderBy?: Record<string, true>;
+    orderBy?: Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;

package/dist/runtime/index.d.ts

@@ -49,11 +49,12 @@ type ModelOpts = {
 });
 type QueryMethod = 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'count' | 'aggregate' | 'groupBy';
 type MutationMethod = 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany';
+type OrderByFieldConfig = true | Record<string, true>;
 interface ShapeConfig {
     where?: Record<string, unknown>;
     include?: Record<string, true | NestedIncludeArgs>;
     select?: Record<string, true | NestedSelectArgs>;
-    orderBy?: Record<string, true>;
+    orderBy?: Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;
@@ -73,7 +74,7 @@ interface NestedIncludeArgs {
     where?: Record<string, unknown>;
     include?: Record<string, true | NestedIncludeArgs>;
     select?: Record<string, true | NestedSelectArgs>;
-    orderBy?: Record<string, true>;
+    orderBy?: Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;
@@ -84,7 +85,7 @@ interface NestedIncludeArgs {
 interface NestedSelectArgs {
     select?: Record<string, true | NestedSelectArgs>;
     where?: Record<string, unknown>;
-    orderBy?: Record<string, true>;
+    orderBy?: Record<string, OrderByFieldConfig>;
     cursor?: Record<string, true>;
     take?: {
         max: number;

package/dist/runtime/index.js

@@ -1254,23 +1254,80 @@ function requireConfigTrue(config, context) {
   }
 }
 function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
+  const sortEnum = z5.enum(["asc", "desc"]);
+  const nullsEnum = z5.enum(["first", "last"]);
+  const sortWithNulls = z5.object({ sort: sortEnum, nulls: nullsEnum.optional() }).strict();
+  const scalarOrderSchema = z5.union([sortEnum, sortWithNulls]);
+  function validateScalarOrderByField(fieldName, model, modelFields) {
+    const fieldMeta = modelFields[fieldName];
+    if (!fieldMeta)
+      throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+    if (fieldMeta.isRelation)
+      throw new ShapeError(`Relation field "${fieldName}" in orderBy requires a nested config object, not true`);
+    if (fieldMeta.type === "Json")
+      throw new ShapeError(`Json field "${fieldName}" cannot be used in orderBy`);
+    if (fieldMeta.isList)
+      throw new ShapeError(`List field "${fieldName}" cannot be used in orderBy`);
+  }
   function buildOrderBySchema(model, orderByConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    requireConfigTrue(orderByConfig, `orderBy on model "${model}"`);
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(orderByConfig)) {
+    for (const [fieldName, config] of Object.entries(orderByConfig)) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
         throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
-      if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in orderBy`);
-      if (fieldMeta.type === "Json")
-        throw new ShapeError(`Json field "${fieldName}" cannot be used in orderBy`);
-      if (fieldMeta.isList)
-        throw new ShapeError(`List field "${fieldName}" cannot be used in orderBy`);
-      fieldSchemas[fieldName] = z5.enum(["asc", "desc"]).optional();
+      if (config === true) {
+        validateScalarOrderByField(fieldName, model, modelFields);
+        fieldSchemas[fieldName] = scalarOrderSchema.optional();
+        continue;
+      }
+      if (typeof config !== "object" || config === null) {
+        throw new ShapeError(`Invalid orderBy config for "${fieldName}" on model "${model}": expected true or a nested config object`);
+      }
+      if (!fieldMeta.isRelation) {
+        throw new ShapeError(`Scalar field "${fieldName}" in orderBy does not accept nested config`);
+      }
+      if (Object.keys(config).length === 0) {
+        throw new ShapeError(`Empty orderBy config for relation "${fieldName}" on model "${model}". Define at least one nested field.`);
+      }
+      if (fieldMeta.isList) {
+        const relKeys = Object.keys(config);
+        if (relKeys.length !== 1 || relKeys[0] !== "_count") {
+          throw new ShapeError(`To-many relation "${fieldName}" in orderBy only supports { _count: true }`);
+        }
+        if (config._count !== true) {
+          throw new ShapeError(`_count in orderBy for "${fieldName}" must be true`);
+        }
+        fieldSchemas[fieldName] = z5.object({ _count: sortEnum }).strict().optional();
+        continue;
+      }
+      const relatedModel = fieldMeta.type;
+      const relatedFields = typeMap[relatedModel];
+      if (!relatedFields)
+        throw new ShapeError(`Related model "${relatedModel}" not found in type map`);
+      const nestedSchemas = {};
+      for (const [nestedField, nestedVal] of Object.entries(config)) {
+        if (nestedVal !== true) {
+          throw new ShapeError(`Nested orderBy field "${nestedField}" on relation "${fieldName}" must be true`);
+        }
+        const nestedMeta = relatedFields[nestedField];
+        if (!nestedMeta)
+          throw new ShapeError(`Unknown field "${nestedField}" on model "${relatedModel}" in orderBy`);
+        if (nestedMeta.isRelation)
+          throw new ShapeError(`Nested relation "${nestedField}" in orderBy on "${fieldName}" is not supported`);
+        if (nestedMeta.type === "Json")
+          throw new ShapeError(`Json field "${nestedField}" cannot be used in orderBy`);
+        if (nestedMeta.isList)
+          throw new ShapeError(`List field "${nestedField}" cannot be used in orderBy`);
+        nestedSchemas[nestedField] = scalarOrderSchema.optional();
+      }
+      const nestedKeys = Object.keys(nestedSchemas);
+      fieldSchemas[fieldName] = z5.object(nestedSchemas).strict().refine(
+        (v) => nestedKeys.some((k) => v[k] !== void 0),
+        { message: `orderBy for relation "${fieldName}" must specify at least one field` }
+      ).optional();
     }
     const fieldKeys = Object.keys(fieldSchemas);
     const singleSchema = z5.object(fieldSchemas).strict().refine(