prostgles-server 4.2.567 → 4.2.570

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;
 }

package/lib/DboBuilder/getColumns.ts

@@ -44,7 +44,7 @@ export async function getColumns(
       }
     }
 
-    const columns: ValidatedColumnInfo[] = this.columns
+    const rawColumns: ValidatedColumnInfo[] = this.columns
       .filter((c) => {
         const { insert, select, update } = rules;
 
@@ -64,13 +64,13 @@ export async function getColumns(
         let update = !!c.privileges.UPDATE;
 
         const prostgles = this.dboBuilder.prostgles;
-        const fileConfig = prostgles.fileManager?.getColInfo({
+        const fileConfig = getFileColumnInfo({
           colName: c.name,
-          tableName: this.name,
+          tableHandler: this,
         });
 
         /** Do not allow updates to file table unless it's to delete fields */
-        if (prostgles.fileManager?.config && prostgles.fileManager.tableName === this.name) {
+        if (prostgles.opts.fileTable?.tableName === this.name) {
           update = false;
         }
 
@@ -110,6 +110,17 @@ export async function getColumns(
       })
       .filter((c) => c.select || c.update || c.delete || c.insert);
 
+    const modifiedTableSchema = await this.dboBuilder.prostgles.opts.modifyClientSchema?.(
+      {
+        name: this.name,
+        ...(await this.getInfo()),
+        columns: rawColumns,
+      },
+      localParams?.isRemoteRequest?.clientInfo,
+    );
+
+    const columns = modifiedTableSchema?.columns ?? rawColumns;
+
     await this._log({
       command: "getColumns",
       localParams,
@@ -141,3 +152,28 @@ function capitalizeFirstLetter(string: string, nonalpha_replacement?: string): s
   const str = replaceNonAlphaNumeric(string, nonalpha_replacement);
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+
+const getFileColumnInfo = (args: {
+  tableHandler: ViewHandler;
+  colName: string;
+}): ValidatedColumnInfo["file"] | undefined => {
+  const fileTableConfig = args.tableHandler.dboBuilder.prostgles.opts.fileTable;
+  if (!fileTableConfig) return undefined;
+  const { colName, tableHandler } = args;
+  const tableName = tableHandler.name;
+  const tableConfig = fileTableConfig.referencedTables?.[tableName];
+  const isReferencingFileTable = tableHandler.columns.some(
+    (c) =>
+      c.name === colName &&
+      c.references &&
+      c.references.some(({ ftable }) => ftable === fileTableConfig.tableName),
+  );
+  const allowAllFiles = { acceptedContent: "*" } as const;
+  if (isReferencingFileTable) {
+    if (tableConfig && typeof tableConfig !== "string") {
+      return tableConfig.referenceColumns[colName] ?? allowAllFiles;
+    }
+    return allowAllFiles;
+  }
+  return undefined;
+};

package/lib/DboBuilder/uploadFile.ts

@@ -1,8 +1,10 @@
+import { randomUUID } from "crypto";
 import type { AnyObject } from "prostgles-types";
 import { getKeys, isObject } from "prostgles-types";
-import type { LocalParams, Media } from "./DboBuilder";
-import type { ValidateRowBasic } from "../PublishParser/PublishParser";
-import type { TableHandler } from "./TableHandler/TableHandler";
+import type { FileTableRow } from "../FileManager/getFileTableConfig";
+import { getValidatedFileType } from "../FileManager/getValidatedFileType";
+import type { FileTableConfig } from "../ProstglesTypes";
+import type { LocalParams } from "./DboBuilder";
 
 export const isFile = (row: any): row is { data: Buffer; name: string } => {
   return Boolean(
@@ -17,41 +19,39 @@ export const isFile = (row: any): row is { data: Buffer; name: string } => {
 
 type UploadFileArgs = {
   row: AnyObject;
-  validate: ValidateRowBasic | undefined;
   localParams: LocalParams | undefined;
   /**
    * Used to update an existing file
    */
-  mediaId?: string;
+  mediaId: string | undefined;
 };
 
-export async function uploadFile(
-  this: TableHandler,
-  { row, localParams, validate, mediaId }: UploadFileArgs,
-): Promise<Media> {
-  if (!this.dboBuilder.prostgles.fileManager) throw "fileManager not set up";
-
-  if (!isFile(row))
+export const uploadFile = async (
+  config: FileTableConfig,
+  { row, localParams, mediaId }: UploadFileArgs,
+): Promise<FileTableRow> => {
+  if (!isFile(row)) {
     throw (
       "Expecting only two properties for file upload: { name: string; data: File | string | Buffer }; but got: " +
       Object.entries(row)
         .map(([k, v]) => `${k}: ${typeof v}`)
         .join(", ")
     );
+  }
+  const storageClient = config.storageClient;
   const { data, name } = row;
 
-  const media_id =
-    mediaId ?? (await this.db.one<{ name: string }>("SELECT gen_random_uuid() as name")).name;
+  const media_id = mediaId ?? randomUUID();
   const nestedInsert = localParams?.nestedInsert;
-  const type = await this.dboBuilder.prostgles.fileManager.getValidatedFileType({
+  const type = await getValidatedFileType(config, {
     file: data,
     fileName: name,
     tableName: nestedInsert?.previousTable,
     colName: nestedInsert?.referencingColumn,
   });
   const media_name = `${media_id}.${type.ext}`;
-  const parsedMediaKeys = ["id", "name", "original_name", "extension", "content_type"] as const;
-  const media: Required<Pick<Media, (typeof parsedMediaKeys)[number]>> = {
+  const _parsedMediaKeys = ["id", "name", "original_name", "extension", "content_type"] as const;
+  const coreInfo: Required<Pick<FileTableRow, (typeof _parsedMediaKeys)[number]>> = {
     id: media_id,
     name: media_name,
     original_name: name,
@@ -59,41 +59,25 @@ export async function uploadFile(
     content_type: type.mime,
   };
 
-  if (validate) {
-    if (!localParams) throw "localParams missing";
-    const parsedMedia = await validate({
-      tx: localParams.tx?.t || this.tx?.t || this.db,
-      row: media,
-      dbx: this.getFinalDbo(localParams),
-      localParams,
-      command: "insert",
-      data: media,
-    });
-    const missingKeys = parsedMediaKeys.filter((k) => !parsedMedia[k]);
-    if (missingKeys.length) {
-      throw `Some keys are missing from file insert validation: ${missingKeys.join(", ")}`;
-    }
-  }
-
-  const _media: Media = await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
-    item: {
-      data,
-      name: media.name,
-      content_type: media.content_type,
-      extension: media.extension,
-    },
-    // imageCompression: {
-    //     inside: {
-    //         width: 1100,
-    //         height: 630
-    //     }
-    // }
+  const uploadedInfo = await storageClient.upload({
+    file: data,
+    fileName: coreInfo.name,
+    contentType: coreInfo.content_type,
   });
 
-  const mediaRow = {
-    ...media,
-    ..._media,
+  const mediaRow: FileTableRow = {
+    signed_url: null,
+    signed_url_expires: null,
+    added: new Date().toISOString(),
+    deleted: null,
+    deleted_from_storage: null,
+    description: "",
+    ...coreInfo,
+    ...uploadedInfo,
+    extension: type.ext,
+    url: uploadedInfo.cloud_url,
+    content_length: String(uploadedInfo.content_length),
   };
 
   return mediaRow;
-}
+};