prostgles-server 4.2.567 → 4.2.569

package/lib/DBSchemaBuilder/getColumnTypescriptDefinition.ts

@@ -10,7 +10,7 @@ import {
 } from "prostgles-types";
 import type { TableSchemaColumn } from "../DboBuilder/DboBuilder";
 import { escapeTSNames } from "../utils/utils";
-import type { TableConfig } from "../TableConfig/TableConfig";
+import type { TableConfig } from "../TableConfig/TableConfigTypes";
 import { getColumnConfig } from "../TableConfig/getColumnConfig";
 
 export const getColumnTypescriptDefinition = ({

package/lib/DBSchemaBuilder/getDBGeneratedSchema.ts

@@ -1,5 +1,5 @@
 import { isDefined, isEmpty, type TableSchema } from "prostgles-types";
-import type { TableConfig } from "../TableConfig/TableConfig";
+import type { TableConfig } from "../TableConfig/TableConfigTypes";
 import { escapeTSNames } from "../utils/utils";
 import { getColumnTypescriptDefinition } from "./getColumnTypescriptDefinition";
 import { fromEntries } from "../PublishParser/applyScopeToTableRules";

package/lib/DboBuilder/DboBuilder.ts

@@ -242,7 +242,7 @@ export class DboBuilder {
         tableOrViewInfo: tov,
         dboBuilder: this,
         tx: undefined,
-        config: this.prostgles.opts.tableConfig?.[tov.name],
+        config: this.prostgles.mergedTableConfig?.[tov.name],
         joinPaths: this.shortestJoinPaths,
       });
       this.dbo[tov.name] = tableHandler;
@@ -270,7 +270,7 @@ export class DboBuilder {
     }
 
     this.tableTsDefinitions = getDBGeneratedSchema({
-      config: this.prostgles.opts.tableConfig,
+      config: this.prostgles.mergedTableConfig,
       tablesOrViews,
     });
     this.functionTsDefinitions = getFunctionsTypescriptSchema(
@@ -306,7 +306,7 @@ export class DboBuilder {
   : { tsSchema: string; tablesOrViews: TableSchema[] } => {
     const getSchema = (tablesOrViews: TableSchema[]) => {
       const tableTsDefinitions = getDBGeneratedSchema({
-        config: this.prostgles.opts.tableConfig,
+        config: this.prostgles.mergedTableConfig,
         tablesOrViews: [
           ...tablesOrViews,
           ...extraTables.filter(
@@ -379,7 +379,7 @@ export class DboBuilder {
           tableOrViewInfo: tov,
           dboBuilder: this,
           tx: { t, dbTX },
-          config: this.prostgles.opts.tableConfig?.[tov.name],
+          config: this.prostgles.mergedTableConfig?.[tov.name],
           joinPaths: this.shortestJoinPaths,
         });
       });

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -9,7 +9,12 @@ import type {
   TableInfo as TInfo,
   UserLike,
 } from "prostgles-types";
-import type { AuthClientRequest, BasicSession, SessionUser } from "../Auth/AuthTypes";
+import type {
+  AuthClientRequest,
+  AuthResultWithSID,
+  BasicSession,
+  SessionUser,
+} from "../Auth/AuthTypes";
 import type { BasicCallback } from "../PubSubManager/PubSubManager";
 import type {
   DeleteRule,
@@ -88,25 +93,6 @@ export type SortItem = {
     }
 );
 
-export type Media = {
-  id?: string;
-  title?: string;
-  extension?: string;
-  content_type?: string;
-  content_length?: number;
-  url?: string;
-  added?: Date;
-  signed_url?: string;
-  signed_url_expires?: number;
-  name?: string;
-  original_name?: string;
-  etag?: string;
-  deleted?: string | null;
-  deleted_from_storage?: string | null;
-};
-
-export type ParsedMedia = Required<Pick<Media, "extension" | "content_type">>;
-
 export type TxCB<R = any, TH = DbTxTableHandlers> = {
   (t: TH, _t: pgPromise.ITask<{}>): R;
 };
@@ -199,6 +185,7 @@ export type LocalParams = {
   clientReq?: AuthClientRequest | undefined;
   isRemoteRequest?: {
     user?: UserLike | undefined;
+    clientInfo: AuthResultWithSID | undefined;
   };
   scope?: PermissionScope | undefined;
   func?: () => any;

package/lib/DboBuilder/TableHandler/TableHandler.ts

@@ -17,8 +17,7 @@ import type {
   UpdateRule,
 } from "../../PublishParser/PublishParser";
 import { getSyncBatchOptions } from "../../PubSubManager/SyncReplication/getSyncBatchOptions";
-import type TableConfigurator from "../../TableConfig/TableConfig";
-import type { TableDefinition } from "../../TableConfig/TableConfig";
+import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
 import type { DboBuilder, Filter, LocalParams, TableHandlers } from "../DboBuilder";
 import { getErrorAsObject, getSerializedClientErrorFromPGError } from "../DboBuilder";
 import type { TableSchema } from "../DboBuilderTypes";
@@ -35,6 +34,7 @@ import { update } from "./update";
 import { updateBatch } from "./updateBatch";
 import { upsert } from "./upsert";
 import { isApplicableHook } from "./isApplicableHook";
+import type { TableConfigurator } from "../../TableConfig/TableConfigurator";
 
 export type ValidatedParams = {
   row: AnyObject;
@@ -85,6 +85,7 @@ export class TableHandler extends ViewHandler {
     row: AnyObject,
     localParams: LocalParams | undefined,
     command: "insert" | "update",
+    filter: AnyObject | undefined,
   ) => {
     const transaction = this.getTransaction(localParams);
     const hooks = this.getBeforeHooks(command, [row]);
@@ -94,11 +95,12 @@ export class TableHandler extends ViewHandler {
       const isApplicable = isApplicableHook(this, [newRow], hook, command);
       if (!isApplicable) continue;
       const hookResult = await hook.validate({
-        command: "insert",
+        command,
         data: newRow,
         dbx: this.getFinalDbo(localParams),
         localParams,
         tx: transaction?.t || this.db,
+        filter,
       });
       if (hookResult) {
         newRow = hookResult.row;
@@ -177,7 +179,8 @@ export class TableHandler extends ViewHandler {
     const hasBeforeHooks =
       command.name !== "delete" && this.getBeforeHooks(command.name, newRows).length > 0;
     return {
-      shouldWrap: !transaction && (hasAfterChecks || hasBeforeHooks),
+      shouldWrap:
+        !transaction && (hasAfterChecks || hasBeforeHooks || this.config?.hooks?.onInsteadOfDelete),
       hasBeforeHooks,
       hasAfterChecks,
     };

package/lib/DboBuilder/TableHandler/delete.ts

@@ -140,16 +140,31 @@ export async function _delete(
       return queryToReturn as unknown[];
     }
 
-    /**
-     * Delete file
-     */
-    if (this.is_media) {
-      const result = await onDeleteFromFileTable.bind(this)({
-        localParams,
+    const transaction = this.getTransaction(localParams);
+    const dbHandler = transaction?.t ?? this.db;
+
+    const isOneOrNone = includes(["row", "value"], params?.returnType);
+    const queryPromise = () =>
+      isOneOrNone ?
+        dbHandler.oneOrNone<AnyObject>(queryWithRLS).then((data) => (data ? [data] : []))
+      : dbHandler.any<AnyObject>(queryWithRLS);
+
+    const onInsteadOfDelete = this.config?.hooks?.onInsteadOfDelete;
+    if (onInsteadOfDelete) {
+      if (!transaction) {
+        throw new Error(
+          "onInsteadOfDelete requires a transaction. Please wrap the delete call in a transaction.",
+        );
+      }
+      const result = await onInsteadOfDelete({
         queryType,
-        returningQuery: undefined,
+        isOneOrNone,
+        dbx: transaction.dbTX,
+        tx: transaction.t,
+        returningQuery,
         filterOpts,
       });
+
       await this._log({
         command: "delete",
         localParams,
@@ -158,16 +173,7 @@ export async function _delete(
       });
       return result;
     }
-
-    const dbHandler = this.getTransaction(localParams)?.t ?? this.db;
-
-    const isOneOrNone = includes(["row", "value"], params?.returnType);
-    const queryPromise =
-      isOneOrNone ?
-        dbHandler.oneOrNone<AnyObject>(queryWithRLS).then((data) => (data ? [data] : []))
-      : dbHandler.any<AnyObject>(queryWithRLS);
-
-    const deletedRows = await queryPromise.catch((err) =>
+    const deletedRows = await queryPromise().catch((err) =>
       rejectWithPGClientError(err, {
         type: "tableMethod",
         localParams,

package/lib/DboBuilder/TableHandler/insert/insert.ts

@@ -93,23 +93,14 @@ export async function insert(
     const successCallbacks: (() => void)[] = [];
     const preValidatedRows: InsertedRowWithInfo[] = await Promise.all(
       rows.map(async (nonValidated) => {
-        const { preValidate, validate } = rule ?? {};
+        const { preValidate } = rule ?? {};
         const { tableConfigurator } = this.dboBuilder.prostgles;
         if (!tableConfigurator) {
           throw "tableConfigurator missing";
         }
-        let row = await tableConfigurator.getPreInsertRow(this, {
-          dbx: this.getFinalDbo(localParams),
-          validate,
-          localParams,
-          row: nonValidated,
-          tx,
-          command: "insert",
-          data: nonValidated,
-        });
 
-        const beforeResult = await this.beforeEach(row, localParams, "insert");
-        row = beforeResult.row;
+        const beforeResult = await this.beforeEach(nonValidated, localParams, "insert", undefined);
+        let row = beforeResult.row;
         beforeResult.successCallbacks.forEach((cb) => successCallbacks.push(cb));
 
         if (preValidate) {

package/lib/DboBuilder/TableHandler/insert/insertNestedRecords.ts

@@ -24,26 +24,22 @@ export async function insertNestedRecords(
   this: TableHandler,
   { data, insertParams, tableRules, localParams }: InsertNestedRecordsArgs,
 ) {
-  const MEDIA_COL_NAMES = ["data", "name"];
-
   const getExtraKeys = (row: AnyObject) =>
     getKeys(row).filter((fieldName) => {
-      /* If media then use file insert columns */
-      if (this.is_media) {
-        return !this.column_names.concat(MEDIA_COL_NAMES).includes(fieldName);
-      } else if (!this.columns.find((c) => c.name === fieldName)) {
-        if (
-          !isObject(row[fieldName]) &&
-          !Array.isArray(row[fieldName]) &&
-          row[fieldName] !== undefined
-        ) {
-          throw new Error("Invalid/Disallowed field in data: " + fieldName);
-        } else if (!this.dboBuilder.dbo[fieldName]) {
-          return false;
-        }
-        return true;
+      const matchingColumn = this.columns.find((c) => c.name === fieldName);
+      if (matchingColumn) return false;
+      if (
+        !isObject(row[fieldName]) &&
+        !Array.isArray(row[fieldName]) &&
+        row[fieldName] !== undefined
+      ) {
+        throw new Error(
+          `Invalid/Disallowed field in data: ${fieldName}. If inserting nested records, the field must be an object or array.`,
+        );
+      } else if (!this.dboBuilder.dboMap.get(fieldName)) {
+        return false;
       }
-      return false;
+      return true;
     });
 
   /**

package/lib/DboBuilder/TableHandler/insert/insertRowWithNestedRecords.ts

@@ -187,7 +187,7 @@ export async function insertRowWithNestedRecords(
       if (!colsRefT1.length || !colsRefT3.length)
         throw "Incorrectly referenced or missing columns for nested insert";
 
-      const fileTable = this.dboBuilder.prostgles.fileManager?.tableName;
+      const fileTable = this.dboBuilder.prostgles.opts.fileTable?.tableName;
       if (targetTable !== fileTable) {
         throw "Only media allowed to have nested inserts more than 2 tables apart";
       }

package/lib/DboBuilder/TableHandler/onDeleteFromFileTable.ts

@@ -1,70 +1,57 @@
+import type pgPromise from "pg-promise";
 import type { AnyObject } from "prostgles-types";
 import { asName, pickKeys } from "prostgles-types";
-import type { LocalParams } from "../DboBuilder";
-import { type Media } from "../DboBuilder";
-import type { TableHandler } from "./TableHandler";
+import type { FileTableConfig } from "../../ProstglesTypes";
+import type { TableHandlers } from "../DboBuilder";
+import type { FileTableRow } from "../../FileManager/getFileTableConfig";
 
 type OnDeleteFromFileTableArgs = {
-  localParams: LocalParams | undefined;
-  queryType: "one" | "none" | "many" | "any";
   returningQuery: undefined | string;
   filterOpts: {
     where: string;
     filter: AnyObject;
   };
+  t: pgPromise.ITask<{}>;
+  dbTX: TableHandlers;
+  isOneOrNone: boolean;
 };
-export async function onDeleteFromFileTable(
-  this: TableHandler,
-  { localParams, queryType, returningQuery, filterOpts }: OnDeleteFromFileTableArgs,
-) {
-  if (!this.dboBuilder.prostgles.fileManager) {
-    throw new Error("fileManager missing");
+export const onDeleteFromFileTable = async (
+  config: FileTableConfig,
+  { dbTX, t, returningQuery, filterOpts, isOneOrNone }: OnDeleteFromFileTableArgs,
+) => {
+  const { storageClient, tableName } = config;
+  const tableHandler = dbTX[tableName];
+  if (!tableHandler) {
+    throw new Error(`TableHandler for ${tableName} not found in dbTX`);
   }
-  if (this.dboBuilder.prostgles.opts.fileTable?.delayedDelete) {
-    return this.dbHandler[queryType]<void>(
-      `UPDATE ${asName(this.name)} SET deleted = now() ${filterOpts.where} ${returningQuery ?? ""};`,
+  if (config.delayedDelete) {
+    const result = await t.any(
+      `UPDATE ${asName(tableName)} SET deleted = now() ${filterOpts.where} ${returningQuery ?? ""};`,
     );
-  } else {
-    const txDelete = async (tbl: TableHandler) => {
-      if (!tbl.tx) throw new Error("Missing transaction object tx");
-      let files: { id: string; name: string }[] = [];
-      const totalFiles = await tbl.count(filterOpts.filter);
-      do {
-        const batch = (await tbl.find(filterOpts.filter, {
-          limit: 100,
-          offset: files.length,
-        })) as Required<Media>[];
-        files = [...files, ...batch];
-      } while (files.length < totalFiles);
-
-      const fileManager = tbl.dboBuilder.prostgles.fileManager;
-      if (!fileManager) throw new Error("fileManager missing");
-
-      for (const file of files) {
-        await tbl.tx.t.any(`DELETE FROM ${asName(this.name)} WHERE id = \${id}`, file);
-      }
-      /** If any table delete fails then do not delete files */
-      for (const file of files) {
-        await fileManager.deleteFile(file.name);
-        /** TODO: Keep track of deleted files in case of failure */
-        // await tbl.t?.any(`UPDATE ${asName(this.name)} SET deleted = NOW(), deleted_from_storage = NOW()  WHERE id = ` + "${id}", file);
-      }
+    return (isOneOrNone ? result[0] : result) as undefined | AnyObject[];
+  }
 
-      if (returningQuery) {
-        return files.map((f) => pickKeys(f, ["id", "name"]));
-      }
+  let files: { id: string; name: string }[] = [];
+  const totalFiles = await tableHandler.count(filterOpts.filter);
+  do {
+    const batch = (await tableHandler.find(filterOpts.filter, {
+      limit: 100,
+      offset: files.length,
+    })) as FileTableRow[];
+    files = [...files, ...batch];
+  } while (files.length < totalFiles);
 
-      return undefined;
-    };
+  for (const file of files) {
+    await t.any(`DELETE FROM ${asName(tableName)} WHERE id = \${id}`, file);
+  }
+  /** If any table delete fails then do not delete files */
+  for (const file of files) {
+    await storageClient.delete(file.name);
+  }
 
-    if (localParams?.tx?.dbTX) {
-      return txDelete(localParams.tx.dbTX[this.name] as TableHandler);
-    } else if (this.tx) {
-      return txDelete(this);
-    } else {
-      return this.dboBuilder.getTX((tx) => {
-        return txDelete(tx[this.name] as TableHandler);
-      });
-    }
+  if (returningQuery) {
+    return files.map((f) => pickKeys(f, ["id", "name"]));
   }
-}
+
+  return undefined;
+};

package/lib/DboBuilder/TableHandler/update.ts

@@ -2,18 +2,17 @@ import type { AnyObject, UpdateParams } from "prostgles-types";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { Filter, LocalParams } from "../DboBuilder";
 import { getErrorAsObject, getSerializedClientErrorFromPGError, withUserRLS } from "../DboBuilder";
+import { getReturnTypeQuery } from "../ViewHandler/getReturnTypeQuery";
 import { prepareNewData } from "./DataValidator";
+import { getInsertTableRules } from "./insert/getInsertTableRules";
 import { getReferenceColumnInserts } from "./insert/getReferenceColumnInserts";
 import { runInsertUpdateQuery } from "./runInsertUpdateQuery";
 import type { TableHandler } from "./TableHandler";
-import { updateFile } from "./updateFile";
-import { getInsertTableRules } from "./insert/getInsertTableRules";
-import { getReturnTypeQuery } from "../ViewHandler/getReturnTypeQuery";
 
 export async function update(
   this: TableHandler,
   filter: Filter,
-  _newData: AnyObject,
+  newData: AnyObject,
   params?: UpdateParams,
   tableRules?: ParsedTableRule,
   localParams?: LocalParams,
@@ -26,27 +25,17 @@ export async function update(
       this.dboBuilder.getTX((th) =>
         (th[this.name] as Partial<typeof this> | undefined)?.[ACTION]?.(
           filter,
-          _newData,
+          newData,
           params,
           tableRules,
           localParams,
         ),
       );
     const rule = tableRules?.[ACTION];
-    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams, [_newData]).shouldWrap) {
+    if (this.shouldWrapInTx({ name: ACTION, rule }, localParams, [newData]).shouldWrap) {
       return wrapInTx();
     }
 
-    let newData = _newData;
-    if (this.is_media) {
-      ({ newData } = await updateFile.bind(this)({
-        newData,
-        filter,
-        localParams,
-        tableRules,
-      }));
-    }
-
     const parsedRules = await this.parseUpdateRules(filter, params, tableRules, localParams);
     if (localParams?.testRule) {
       return parsedRules;
@@ -76,7 +65,7 @@ export async function update(
         );
     }
 
-    const beforeResult = await this.beforeEach(newData, localParams, "update");
+    const beforeResult = await this.beforeEach(newData, localParams, "update", filter);
     newData = beforeResult.row;
 
     const { data, allowedCols } = prepareNewData({
@@ -206,7 +195,7 @@ export async function update(
     await this._log({
       command: "update",
       localParams,
-      data: { filter, _newData, params },
+      data: { filter, newData, params },
       duration: Date.now() - start,
     });
     beforeResult.successCallbacks.forEach((cb) => cb());
@@ -215,7 +204,7 @@ export async function update(
     await this._log({
       command: "update",
       localParams,
-      data: { filter, _newData, params },
+      data: { filter, newData, params },
       duration: Date.now() - start,
       error: getErrorAsObject(e),
     });

package/lib/DboBuilder/TableHandler/updateFile.ts

@@ -1,71 +1,49 @@
-import type { AnyObject} from "prostgles-types";
+import type { AnyObject } from "prostgles-types";
 import { getJSONBObjectSchemaValidationError, omitKeys } from "prostgles-types";
-import type { ParsedTableRule, ValidateRowBasic } from "../../PublishParser/PublishParser";
-import type { LocalParams, Media } from "../DboBuilder";
+import type { FileTableRow } from "../../FileManager/getFileTableConfig";
+import type { FileTableConfig } from "../../ProstglesTypes";
+import type { LocalParams } from "../DboBuilder";
 import { isFile, uploadFile } from "../uploadFile";
 import type { TableHandler } from "./TableHandler";
 
 type Args = {
   newData: AnyObject;
   filter: AnyObject;
-  tableRules: ParsedTableRule | undefined;
   localParams: LocalParams | undefined;
 };
-export const updateFile = async function (
-  this: TableHandler,
-  { filter, newData, tableRules, localParams }: Args
-): Promise<{ newData: AnyObject }> {
-  const rule = tableRules?.update;
-
-  if (tableRules && !tableRules.update) {
-    throw "Not allowed";
-  }
-  if (localParams?.testRule) {
-    return { newData: {} };
-  }
-
+export const updateFile = async (
+  tableHandler: TableHandler,
+  config: FileTableConfig,
+  { filter, newData, localParams }: Args,
+): Promise<{ newData: AnyObject }> => {
   const { data } = getJSONBObjectSchemaValidationError(
     { id: { optional: true, type: "string" } },
     filter,
-    "filter"
+    "filter",
   );
   const existingMediaId = data?.id;
   if (!existingMediaId) {
     throw new Error(
-      `Updating the file table with file data can only be done by providing a single id filter. E.g. { id: "9ea4e23c-2b1a-4e33-8ec0-c15919bb45ec" } `
+      `Updating the file table with file data can only be done by providing a single id filter. E.g. { id: "9ea4e23c-2b1a-4e33-8ec0-c15919bb45ec" } `,
     );
   }
   if (!isFile(newData)) {
     throw new Error(
-      "Expecting { data: Buffer, name: string } but received " + JSON.stringify(newData)
+      "Expecting { data: Buffer, name: string } but received " + JSON.stringify(newData),
     );
   }
 
-  const fileManager = this.dboBuilder.prostgles.fileManager;
-  if (!fileManager) throw new Error("fileManager missing");
-  if (rule?.validate && !localParams) throw new Error("localParams missing");
-  const validate: ValidateRowBasic | undefined =
-    rule?.validate ?
-      async (row) => {
-        return rule.validate!({
-          update: row,
-          filter,
-          dbx: this.tx?.dbTX || this.dboBuilder.dbo,
-          localParams: localParams!,
-        });
-      }
-    : undefined;
-
-  const existingFile: Media | undefined = await (
-    (localParams?.tx?.dbTX[this.name]) || this
-  ).findOne({ id: existingMediaId });
+  const existingFile = (await tableHandler.findOne({
+    id: existingMediaId,
+  })) as FileTableRow | undefined;
 
-  if (!existingFile?.name) throw new Error("Existing file record not found");
+  if (!existingFile?.name) {
+    throw new Error("Existing file record not found");
+  }
 
-  await fileManager.deleteFile(existingFile.name);
-  const newFile = await uploadFile.bind(this)({
+  await config.storageClient.delete(existingFile.name);
+  const newFile = await uploadFile(config, {
     row: newData,
-    validate,
     localParams,
     mediaId: existingFile.id,
   });

package/lib/DboBuilder/ViewHandler/ViewHandler.ts

@@ -29,7 +29,7 @@ import type { OnData } from "./subscribe";
 import { subscribe } from "./subscribe";
 import { validateViewRules } from "./validateViewRules";
 import { escapeTSNames } from "../../utils/utils";
-import type { TableDefinition } from "../../TableConfig/TableConfig";
+import type { TableDefinition } from "../../TableConfig/TableConfigTypes";
 import { getDbHandlerWithAbort } from "./getDbHandlerWithAbort";
 import type { VoidFunction } from "../../SchemaWatch/SchemaWatch";
 

package/lib/DboBuilder/ViewHandler/getInfo.ts

@@ -1,4 +1,4 @@
-import type { TableInfo as TInfo } from "prostgles-types/dist";
+import { type TableInfo as TInfo } from "prostgles-types/dist";
 import type { ParsedTableRule } from "../../PublishParser/PublishParser";
 import type { LocalParams } from "../DboBuilder";
 import type { ViewHandler } from "./ViewHandler";
@@ -27,7 +27,7 @@ export async function getInfo(
     tableName: this.name,
     lang,
   });
-  return {
+  const tableInfo: TInfo = {
     oid: this.tableOrViewInfo.oid,
     comment: this.tableOrViewInfo.comment,
     qualifiedNameParts: this.tableOrViewInfo.qualifiedNameParts,
@@ -69,4 +69,21 @@ export async function getInfo(
       delete: validatedTableRules.delete && {},
     },
   };
+
+  const modifyClientSchema = this.dboBuilder.prostgles.opts.modifyClientSchema;
+  if (!modifyClientSchema) {
+    return tableInfo;
+  }
+
+  const modifiedTableSchema = await modifyClientSchema(
+    {
+      name: this.name,
+      ...tableInfo,
+      columns: [],
+    },
+    localParams?.isRemoteRequest?.clientInfo,
+  );
+
+  const { columns, name, ...rest } = modifiedTableSchema;
+  return rest;
 }