alepha 0.20.2 → 0.20.3

package/src/security/primitives/$basicAuth.ts

@@ -39,7 +39,7 @@ export function $basicAuth(options: BasicAuthOptions): Middleware {
 
         const authHeader = request.headers.authorization;
 
-        if (!authHeader || !authHeader.startsWith("Basic ")) {
+        if (!authHeader?.startsWith("Basic ")) {
           sendAuthRequired(request);
           throw new HttpError({
             status: 401,

package/src/server/auth/providers/ServerAuthProvider.ts

@@ -114,7 +114,7 @@ export class ServerAuthProvider {
       // [feature] support for auth providers with fallback
       if (!request.headers.authorization) {
         for (const provider of this.identities) {
-          if ("fallback" in provider.options && !!provider.options.fallback) {
+          if ("fallback" in provider.options && provider.options.fallback) {
             const token = await provider.options.fallback();
             if (token) {
               request.headers.authorization = `Bearer ${token}`;
@@ -336,10 +336,12 @@ export class ServerAuthProvider {
           parameters.scope = scope;
         }
 
+        // biome-ignore lint/complexity/useOptionalChain: oidc is `false | OidcOptions`; optional chaining doesn't narrow `false`
         if (oidc && oidc.responseMode) {
           parameters.response_mode = oidc.responseMode;
         }
 
+        // biome-ignore lint/complexity/useOptionalChain: oidc is `false | OidcOptions`; optional chaining doesn't narrow `false`
         if (oidc && oidc.authorizationParameters) {
           Object.assign(parameters, oidc.authorizationParameters);
         }
@@ -381,10 +383,12 @@ export class ServerAuthProvider {
         parameters.scope = scope;
       }
 
+      // biome-ignore lint/complexity/useOptionalChain: oidc is `false | OidcOptions`; optional chaining doesn't narrow `false`
       if (oidc && oidc.responseMode) {
         parameters.response_mode = oidc.responseMode;
       }
 
+      // biome-ignore lint/complexity/useOptionalChain: oidc is `false | OidcOptions`; optional chaining doesn't narrow `false`
       if (oidc && oidc.authorizationParameters) {
         Object.assign(parameters, oidc.authorizationParameters);
       }

package/src/server/core/interfaces/ServerRequest.ts

@@ -212,6 +212,7 @@ export type ResponseKind = "json" | "text" | "void" | "file" | "any";
 
 export type ResponseBodyType =
   // not: object is not allowed, you want object ? add schema !
+  // biome-ignore lint/suspicious/noConfusingVoidType: handlers may return void (no return statement)
   string | Buffer | StreamLike | undefined | null | void;
 
 export type ServerHandler<

package/src/server/core/providers/ServerProvider.ts

@@ -411,7 +411,7 @@ export class ServerProvider {
 
       url = url?.split("?")[0];
 
-      if (!!params?.["*"] && `/${params?.["*"]}` === url) {
+      if (params?.["*"] && `/${params?.["*"]}` === url) {
         return true;
       }
     }

package/src/server/core/providers/ServerRouterProvider.ts

@@ -319,7 +319,7 @@ export class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     }
 
     if (reply.body == null || responseKind === "void") {
-      delete headers["content-type"];
+      delete (headers as Record<string, unknown>)["content-type"];
       reply.body = undefined;
       return;
     }
@@ -416,7 +416,7 @@ export class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     if (
       "status" in error &&
       typeof error.status === "number" &&
-      !!errorNameByStatus[error.status]
+      errorNameByStatus[error.status]
     ) {
       const status = error.status;
       reply.status = status;

package/src/server/core/services/HttpClient.ts

@@ -213,7 +213,7 @@ export class HttpClient {
 
     if (hasHeader || isMultipart(action)) {
       if (typeof init.headers === "object" && "content-type" in init.headers) {
-        delete init.headers["content-type"]; // fetch() will fill this for us
+        delete (init.headers as Record<string, unknown>)["content-type"]; // fetch() will fill this for us
       }
 
       const formData = new FormData();

package/src/server/swagger/providers/ServerSwaggerProvider.ts

@@ -260,7 +260,7 @@ export class ServerSwaggerProvider {
               ? value.description
               : undefined;
           const ref = schema(value);
-          delete ref.description;
+          ref.description = undefined;
           const param: any = {
             name: key,
             in: "path",

package/dist/react/testing/chunk-DBEY4PJZ.js

@@ -1,16 +0,0 @@
-import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
-export { __exportAll as n, __require as r, __commonJSMin as t };

package/src/orm/core/__tests__/parseQueryString.spec.ts

@@ -1,196 +0,0 @@
-import { describe, test } from "vitest";
-import { buildQueryString, parseQueryString } from "../index.ts";
-
-describe("parseQueryString with wildcard patterns", () => {
-  test("should parse wildcard patterns with = operator", ({ expect }) => {
-    // Test startsWith pattern
-    const result1 = parseQueryString("name=John*");
-    expect(result1).toEqual({ name: { startsWith: "John" } });
-
-    // Test endsWith pattern
-    const result2 = parseQueryString("name=*Smith");
-    expect(result2).toEqual({ name: { endsWith: "Smith" } });
-
-    // Test contains pattern
-    const result3 = parseQueryString("name=*oh*");
-    expect(result3).toEqual({ name: { contains: "oh" } });
-
-    // Test literal asterisk in the middle (not at beginning or end)
-    const result4 = parseQueryString("name=Jo*hn");
-    expect(result4).toEqual({ name: { eq: "Jo*hn" } });
-
-    // Test literal equals (no wildcards)
-    const result5 = parseQueryString("name=John");
-    expect(result5).toEqual({ name: { eq: "John" } });
-  });
-
-  test("should handle wildcard patterns in complex queries", ({ expect }) => {
-    // Multiple conditions with wildcards
-    const result1 = parseQueryString("name=*John&email=*@example.com");
-    expect(result1).toEqual({
-      and: [
-        { name: { endsWith: "John" } },
-        { email: { endsWith: "@example.com" } },
-      ],
-    });
-
-    // OR conditions with wildcards
-    const result2 = parseQueryString("name=John*|name=*Smith");
-    expect(result2).toEqual({
-      or: [{ name: { startsWith: "John" } }, { name: { endsWith: "Smith" } }],
-    });
-
-    // Nested conditions with wildcards
-    const result3 = parseQueryString("(name=*John*|email=admin*)&age>18");
-    expect(result3).toEqual({
-      and: [
-        {
-          or: [
-            { name: { contains: "John" } },
-            { email: { startsWith: "admin" } },
-          ],
-        },
-        { age: { gt: 18 } },
-      ],
-    });
-  });
-
-  test("should handle wildcard patterns in quoted strings", ({ expect }) => {
-    // Quoted string with wildcards should be treated as wildcards
-    const result1 = parseQueryString('name="*John*"');
-    expect(result1).toEqual({ name: { contains: "John" } });
-
-    // Quoted string with asterisk in middle
-    const result2 = parseQueryString('name="Jo*hn"');
-    expect(result2).toEqual({ name: { eq: "Jo*hn" } });
-
-    // Single quotes
-    const result3 = parseQueryString("name='*Smith'");
-    expect(result3).toEqual({ name: { endsWith: "Smith" } });
-  });
-
-  test("should handle wildcard patterns with special characters", ({
-    expect,
-  }) => {
-    // Wildcard with spaces
-    const result1 = parseQueryString("name=*John Smith*");
-    expect(result1).toEqual({ name: { contains: "John Smith" } });
-
-    // Wildcard with special characters
-    const result2 = parseQueryString("email=*@example.com");
-    expect(result2).toEqual({ email: { endsWith: "@example.com" } });
-
-    // Wildcard with numbers
-    const result3 = parseQueryString("code=ABC*123");
-    expect(result3).toEqual({ code: { eq: "ABC*123" } }); // Asterisk in middle is literal
-  });
-
-  test("should handle wildcard patterns in arrays", ({ expect }) => {
-    // Array values don't support wildcards (treated as literal)
-    const result = parseQueryString("status=[active*,*pending,*idle*]");
-    expect(result).toEqual({
-      status: { inArray: ["active*", "*pending", "*idle*"] },
-    });
-  });
-
-  test("should handle wildcard patterns with != operator", ({ expect }) => {
-    // != operator doesn't support wildcards, treats as literal
-    const result1 = parseQueryString("name!=*John");
-    expect(result1).toEqual({ name: { ne: "*John" } });
-
-    const result2 = parseQueryString("name!=John*");
-    expect(result2).toEqual({ name: { ne: "John*" } });
-  });
-
-  test("should handle empty wildcard patterns", ({ expect }) => {
-    // Just asterisks - a single asterisk at the end means "starts with nothing" = everything
-    const result1 = parseQueryString("name=*");
-    expect(result1).toEqual({ name: { contains: "" } }); // Since * alone has both start and end asterisk
-
-    const result2 = parseQueryString("name=**");
-    expect(result2).toEqual({ name: { contains: "" } });
-
-    const result3 = parseQueryString("name=***");
-    expect(result3).toEqual({ name: { contains: "*" } });
-  });
-
-  test("should handle JSONB nested queries with wildcards", ({ expect }) => {
-    const result = parseQueryString("profile.city=*Paris*&profile.name=John*");
-    expect(result).toEqual({
-      and: [
-        { profile: { city: { contains: "Paris" } } },
-        { profile: { name: { startsWith: "John" } } },
-      ],
-    });
-  });
-
-  test("should not apply wildcards to non-string operators", ({ expect }) => {
-    // Numeric comparison operators don't use wildcards
-    const result1 = parseQueryString("age>18");
-    expect(result1).toEqual({ age: { gt: 18 } });
-
-    // NULL checks don't use wildcards
-    const result2 = parseQueryString("name=null");
-    expect(result2).toEqual({ name: { isNull: true } });
-
-    const result3 = parseQueryString("name!=null");
-    expect(result3).toEqual({ name: { isNotNull: true } });
-  });
-});
-
-describe("buildQueryString with wildcard patterns", () => {
-  test("should build query strings from wildcard conditions", ({ expect }) => {
-    // startsWith
-    const query1 = buildQueryString({ name: { startsWith: "John" } });
-    expect(query1).toBe("name=John*");
-
-    // endsWith
-    const query2 = buildQueryString({ name: { endsWith: "Smith" } });
-    expect(query2).toBe("name=*Smith");
-
-    // contains
-    const query3 = buildQueryString({ name: { contains: "oh" } });
-    expect(query3).toBe("name=*oh*");
-  });
-
-  test("should build complex query strings with wildcards", ({ expect }) => {
-    const query = buildQueryString({
-      and: [
-        { name: { startsWith: "John" } },
-        { email: { endsWith: "@example.com" } },
-        { bio: { contains: "developer" } },
-      ],
-    });
-    expect(query).toBe("name=John*&email=*@example.com&bio=*developer*");
-  });
-
-  test("should handle OR conditions with wildcards", ({ expect }) => {
-    const query = buildQueryString({
-      or: [
-        { name: { startsWith: "Admin" } },
-        { role: { contains: "manager" } },
-      ],
-    });
-    expect(query).toBe("(name=Admin*|role=*manager*)");
-  });
-
-  test("round-trip conversion should preserve wildcard semantics", ({
-    expect,
-  }) => {
-    const testCases = [
-      "name=John*",
-      "name=*Smith",
-      "name=*John*",
-      "email=admin*&role=*manager*",
-      "(name=*John*|name=*Jane*)&active=true",
-      "profile.city=*Paris*",
-    ];
-
-    for (const original of testCases) {
-      const parsed = parseQueryString(original);
-      const rebuilt = buildQueryString(parsed);
-      const reparsed = parseQueryString(rebuilt);
-      expect(reparsed).toEqual(parsed);
-    }
-  });
-});