prostgles-types 4.0.307 → 4.0.309

package/lib/authContract.ts

@@ -0,0 +1,92 @@
+import { authResponseSchemas } from "./authResponseSchemas";
+import type { JSONB } from "./JSONBSchemaValidation/JSONBSchema";
+import type {
+  RequestResponseCall,
+  RequestResponseHandler,
+  RequestResponseSchema,
+} from "./requestResponse";
+
+const credentials = {
+  username: "string",
+  password: { type: "string", optional: true },
+} as const;
+
+export const authContract = {
+  login: {
+    request: {
+      type: {
+        ...credentials,
+        remember_me: { type: "boolean", optional: true },
+        totp_token: { type: "string", optional: true },
+        totp_recovery_code: { type: "string", optional: true },
+      },
+    },
+    response: {
+      oneOf: [
+        authResponseSchemas.authSuccess,
+        authResponseSchemas.passwordLoginFailure,
+        authResponseSchemas.magicLinkAuthSuccess,
+        authResponseSchemas.magicLinkAuthFailure,
+        authResponseSchemas.oauthRegisterFailure,
+        authResponseSchemas.codeVerificationFailure,
+      ],
+    },
+  },
+  register: {
+    request: { type: credentials },
+    response: {
+      oneOf: [
+        authResponseSchemas.passwordRegisterSuccess,
+        authResponseSchemas.passwordRegisterFailure,
+      ],
+    },
+  },
+  magicLinkOrOTP: {
+    request: {
+      oneOfType: [
+        { id: "string", returnToken: { type: "boolean", optional: true } },
+        {
+          email: "string",
+          code: "string",
+          returnToken: { type: "boolean", optional: true },
+        },
+      ],
+    },
+    response: {
+      oneOf: [
+        authResponseSchemas.authSuccess,
+        authResponseSchemas.emailConfirmationSuccess,
+        authResponseSchemas.magicLinkAuthFailure,
+        authResponseSchemas.codeVerificationFailure,
+        authResponseSchemas.invalidEmail,
+      ],
+    },
+  },
+  logout: {
+    request: { type: {} },
+    response: {
+      oneOf: [
+        authResponseSchemas.authSuccess,
+        authResponseSchemas.commonFailure,
+      ],
+    },
+  },
+} as const satisfies Record<string, RequestResponseSchema>;
+
+export type AuthOperation = keyof typeof authContract;
+export type AuthInput<Operation extends AuthOperation> = JSONB.GetType<
+  (typeof authContract)[Operation]["request"]
+>;
+export type AuthOutput<Operation extends AuthOperation> = JSONB.GetType<
+  (typeof authContract)[Operation]["response"]
+>;
+export type AuthCalls = {
+  [Operation in AuthOperation]: RequestResponseCall<
+    (typeof authContract)[Operation]
+  >;
+};
+export type AuthHandlers = {
+  [Operation in AuthOperation]: RequestResponseHandler<
+    (typeof authContract)[Operation]
+  >;
+};

package/lib/authResponseSchemas.ts

@@ -0,0 +1,113 @@
+import type { JSONB } from "./JSONBSchemaValidation/JSONBSchema";
+
+const message = { type: "string", optional: true } as const;
+const success = { success: { enum: [true] }, message } as const;
+const failure = { success: { enum: [false] }, message } as const;
+const commonFailureCodes = [
+  "server-error",
+  "rate-limit-exceeded",
+  "something-went-wrong",
+] as const;
+const authFailureCodes = [
+  ...commonFailureCodes,
+  "no-match",
+  "inactive-account",
+] as const;
+
+export const authResponseSchemas = {
+  authSuccess: {
+    type: {
+      ...success,
+      code: { enum: [undefined], optional: true },
+      token: { type: "string", optional: true },
+    },
+  },
+  commonFailure: { type: { ...failure, code: { enum: commonFailureCodes } } },
+  authFailure: { type: { ...failure, code: { enum: authFailureCodes } } },
+  magicLinkAuthSuccess: {
+    type: {
+      ...success,
+      code: { enum: ["email-verification-code-sent", "magic-link-sent"] },
+    },
+  },
+  magicLinkAuthFailure: {
+    type: {
+      ...failure,
+      code: {
+        enum: [
+          ...authFailureCodes,
+          "expired-magic-link",
+          "invalid-magic-link",
+          "used-magic-link",
+        ],
+      },
+    },
+  },
+  oauthRegisterFailure: {
+    type: {
+      ...failure,
+      code: { enum: [...commonFailureCodes, "provider-issue"] },
+    },
+  },
+  passwordLoginFailure: {
+    type: {
+      ...failure,
+      code: {
+        enum: [
+          ...authFailureCodes,
+          "totp-token-missing",
+          "invalid-username",
+          "username-missing",
+          "invalid-email",
+          "password-missing",
+          "invalid-password",
+          "is-from-OAuth",
+          "is-from-magic-link",
+          "invalid-totp-recovery-code",
+          "invalid-totp-code",
+          "email-not-confirmed",
+        ],
+      },
+    },
+  },
+  passwordRegisterFailure: {
+    type: {
+      ...failure,
+      code: {
+        enum: [
+          ...commonFailureCodes,
+          "weak-password",
+          "user-already-registered",
+          "username-missing",
+          "password-missing",
+          "invalid-email-confirmation-code",
+          "expired-email-confirmation-code",
+          "inactive-account",
+        ],
+      },
+    },
+  },
+  passwordRegisterSuccess: {
+    type: {
+      ...success,
+      code: {
+        enum: [
+          "email-verification-code-sent",
+          "already-registered-but-did-not-confirm-email",
+        ],
+      },
+    },
+  },
+  codeVerificationFailure: {
+    type: {
+      ...failure,
+      code: {
+        enum: [...authFailureCodes, "invalid-otp-code", "expired-otp-code"],
+      },
+    },
+  },
+  emailConfirmationSuccess: {
+    type: { ...success, code: { enum: ["email-verified"] } },
+  },
+  invalidEmail: { type: { ...failure, code: { enum: ["invalid-email"] } } },
+} as const satisfies Record<string, JSONB.FieldTypeObj>;

package/lib/index.ts

@@ -440,7 +440,9 @@ export const getAllowedTableMethods = ({
       if (!publishInfo.select) return false;
       const disabledMethod = cmd === "subscribeOne" ? "subscribe" : cmd;
       return (
-        !Object.keys(publishInfo.select.disabledMethods ?? {}).includes(disabledMethod) &&
+        !Object.keys(publishInfo.select.disabledMethods ?? {}).includes(
+          disabledMethod,
+        ) &&
         (cmd !== "sync" || publishInfo.select.syncConfig !== undefined)
       );
     }),
@@ -1727,6 +1729,8 @@ export const getPossibleNestedInsert = (
 };
 
 export * from "./auth";
+export * from "./authContract";
+export * from "./requestResponse";
 export { CONTENT_TYPE_TO_EXT } from "./files";
 export type {
   ALLOWED_CONTENT_TYPE,

package/lib/replication.ts

@@ -1,4 +1,9 @@
 import { AnyObject, type EqualityFilter } from "./filters";
+import type {
+  RequestResponseCall,
+  RequestResponseHandler,
+  RequestResponseSchema,
+} from "./requestResponse";
 import {
   CHANNEL_PREFIX,
   createPromiseWithTimeout,
@@ -106,13 +111,17 @@ export type ClientSyncHandles = {
    * Used by client to notify server that data has changed (and send express data if necessary)
    * Also used by server to request client ClientSyncInfo
    */
-  onSyncRequest: (params: SyncBatchParams) => MaybePromise<ClientSyncInfo | ClientExpressData>;
+  onSyncRequest: (
+    params: SyncBatchParams,
+  ) => MaybePromise<ClientSyncInfo | ClientExpressData>;
 
   /**
    * Used to respond to server with the requested data
    * @description: server will send { onPullRequest: { from_synced, limit, ...etc } }
    */
-  onPullRequest: (params: SyncBatchParams) => MaybePromise<ClientSyncPullResponse>;
+  onPullRequest: (
+    params: SyncBatchParams,
+  ) => MaybePromise<ClientSyncPullResponse>;
 
   /**
    * Used to set the data sent by server.
@@ -146,11 +155,9 @@ export const getSyncChannelName = ({
 
 export type SocketCallback = (err?: unknown, res?: unknown) => void;
 
-type RequestBase = {
+type RequestBase = RequestResponseSchema & {
   name: string;
   source: "client" | "server";
-  request: Omit<JSONB.FieldTypeObj, "optional">;
-  response: Omit<JSONB.FieldTypeObj, "optional">;
 };
 export namespace ReplicationProtocol {
   const TIMEOUT = 10_000;
@@ -181,7 +188,9 @@ export namespace ReplicationProtocol {
   } as const satisfies RequestBase;
 
   export type CreateSchemaRequest = JSONB.GetType<typeof CreateSchema.request>;
-  export type CreateSchemaResponse = JSONB.GetType<typeof CreateSchema.response>;
+  export type CreateSchemaResponse = JSONB.GetType<
+    typeof CreateSchema.response
+  >;
 
   const ClientSyncInfoSchema = {
     state: { enum: ["syncing"] },
@@ -235,7 +244,10 @@ export namespace ReplicationProtocol {
       oneOfType: [ClientSyncInfoSchema, ClientExpressDataSchema],
     },
     response: {
-      oneOfType: [{ success: { enum: [true] } }, { success: { enum: [false] }, err: "unknown" }],
+      oneOfType: [
+        { success: { enum: [true] } },
+        { success: { enum: [false] }, err: "unknown" },
+      ],
     },
   } as const satisfies RequestBase;
 
@@ -295,20 +307,27 @@ export namespace ReplicationProtocol {
     },
   } as const satisfies RequestBase;
 
-  const Schemas = { ClientSyncRequest, ServerSyncRequest, PullRequest, UpdateRequest } as const;
+  const Schemas = {
+    ClientSyncRequest,
+    ServerSyncRequest,
+    PullRequest,
+    UpdateRequest,
+  } as const;
   type SchemasType = typeof Schemas;
   const SchemasList = Object.values(Schemas);
 
   export type IncomingHandlers<Side extends RequestBase["source"]> = {
-    [K in keyof SchemasType as SchemasType[K]["source"] extends Side ? never : K]: (
-      params: JSONB.GetType<SchemasType[K]["request"]>,
-    ) => MaybePromise<JSONB.GetType<SchemasType[K]["response"]>>;
+    [
+      K in keyof SchemasType as SchemasType[K]["source"] extends Side ? never
+      : K
+    ]: RequestResponseHandler<SchemasType[K]>;
   };
 
   export type OutgoingHandlers<Side extends RequestBase["source"]> = {
-    [K in keyof SchemasType as SchemasType[K]["source"] extends Side ? K : never]: (
-      params: JSONB.GetType<SchemasType[K]["request"]>,
-    ) => Promise<JSONB.GetType<SchemasType[K]["response"]>>;
+    [
+      K in keyof SchemasType as SchemasType[K]["source"] extends Side ? K
+      : never
+    ]: RequestResponseCall<SchemasType[K]>;
   };
 
   const getHandlers = <Side extends RequestBase["source"]>(
@@ -336,7 +355,9 @@ export namespace ReplicationProtocol {
         return;
       }
 
-      const schema = SchemasList.find((s) => s.name === type && s.source !== side);
+      const schema = SchemasList.find(
+        (s) => s.name === type && s.source !== side,
+      );
       if (!schema) {
         cb("Invalid data.type");
         return;
@@ -349,9 +370,16 @@ export namespace ReplicationProtocol {
 
       /** Must validate incoming data */
       if (side === "server") {
-        const validationResult = getJSONBSchemaValidationError(schema.request, request);
+        const validationResult = getJSONBSchemaValidationError(
+          schema.request,
+          request,
+        );
         if (validationResult.error !== undefined) {
-          console.error("Invalid request from client", validationResult.error, request);
+          console.error(
+            "Invalid request from client",
+            validationResult.error,
+            request,
+          );
           cb(validationResult.error);
           return;
         }
@@ -378,24 +406,28 @@ export namespace ReplicationProtocol {
             key,
             (request: unknown) => {
               return createPromiseWithTimeout((resolve, reject) => {
-                socket.emit(channelName, { type: schema.name, request }, (response: unknown) => {
-                  if (side === "server") {
-                    const validationResult = getJSONBSchemaValidationError(
-                      schema.response,
-                      response,
-                    );
-                    if (validationResult.error !== undefined) {
-                      console.error(
-                        "Invalid response from client for " + schema.name,
-                        validationResult.error,
+                socket.emit(
+                  channelName,
+                  { type: schema.name, request },
+                  (response: unknown) => {
+                    if (side === "server") {
+                      const validationResult = getJSONBSchemaValidationError(
+                        schema.response,
                         response,
                       );
-                      reject(validationResult.error);
-                      return;
+                      if (validationResult.error !== undefined) {
+                        console.error(
+                          "Invalid response from client for " + schema.name,
+                          validationResult.error,
+                          response,
+                        );
+                        reject(validationResult.error);
+                        return;
+                      }
                     }
-                  }
-                  resolve(response);
-                });
+                    resolve(response);
+                  },
+                );
               }, TIMEOUT);
             },
           ] as const;

package/lib/requestResponse.ts

@@ -0,0 +1,15 @@
+import type { JSONB } from "./JSONBSchemaValidation/JSONBSchema";
+import type { MaybePromise } from "./index";
+
+export type RequestResponseSchema = {
+  request: Omit<JSONB.FieldTypeObj, "optional">;
+  response: Omit<JSONB.FieldTypeObj, "optional">;
+};
+
+export type RequestResponseHandler<Schema extends RequestResponseSchema> = (
+  data: JSONB.GetType<Schema["request"]>,
+) => MaybePromise<JSONB.GetType<Schema["response"]>>;
+
+export type RequestResponseCall<Schema extends RequestResponseSchema> = (
+  data: JSONB.GetType<Schema["request"]>,
+) => Promise<JSONB.GetType<Schema["response"]>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-types",
-  "version": "4.0.307",
+  "version": "4.0.309",
   "description": "",
   "main": "dist/index_umd.js",
   "types": "dist/index.d.ts",