sidferreira · September 13, 2024 04:41 · sidferreira · Nov 14, 2021 · fullstackNRJ · Feb 17, 2022
diff --git a/readme.md b/readme.md
diff --git a/getDatabasePath.android.js b/getDatabasePath.android.js
 import RNFS from "react-native-fs";

 // Currently android will add `.db` to file name...
 async function getDatabasePath(dbName) {
  let dbPath = `${RNFS.DocumentDirectoryPath}/${dbName}`;

  const exists = await RNFS.exists(dbPath.concat(".db"));
  if (!exists) {
    try {
      await RNFS.copyFileAssets(dbName.concat(".db"), dbPath.concat(".db"));
    } catch (e) {
      console.log(">>> getDatabasePath error", e);
    }
  }

  return dbPath;
 }

 export default getDatabasePath;
diff --git a/getDatabasePath.ios.js b/getDatabasePath.ios.js
 import RNFS from 'react-native-fs';
 import * as RNZIP from 'react-native-zip-archive

 async function getDatabasePath(dbName) {
  let sanitizedDbName = dbName;

  if (!sanitizedDbName.endsWith(".db")) {
    sanitizedDbName = sanitizedDbName.concat(".db");
  }

  let dbPath = `${RNFS.DocumentDirectoryPath}/${sanitizedDbName}`;

  const exists = await RNFS.exists(dbPath);
  if (!exists) {
    const assetPath = `${RNFS.MainBundlePath}/${sanitizedDbName.replace(
      ".db",
      ".zip"
    )}`;
    const existsZip = await RNFS.exists(assetPath);
    if (existsZip) {
      const tmpPath = `${RNFS.DocumentDirectoryPath}/tmp`;
      await RNZIP.unzip(assetPath, tmpPath);
      await RNFS.moveFile(`${tmpPath}/${sanitizedDbName}`, dbPath);
      await RNFS.unlink(tmpPath);
    }
  }
  return dbPath;
 }
 export default getDatabasePath;
diff --git a/getDatabasePath.js b/getDatabasePath.js
 async function getDatabasePath(dbName) {
  let fullDbName = dbName;

  if (!fullDbName.endsWith('.db') && !fullDbName.includes('?')) {
    fullDbName = fullDbName.concat('.db');
  }

  let dbPath = dbName.includes(process.cwd())
    ? fullDbName
    : `${process.cwd()}/${fullDbName}`;

  return dbPath;
 }

 export default getDatabasePath;
diff --git a/index.ts b/index.ts
 import getDatabasePath from './getDatabasePath';

 const DEFAULT_DATABASE_NAME = 'watermelon';

 const promises: { [key: string]: Promise<Database> } = {};
 const instances: { [key: string]: Database } = {};

 async function init(dbName: string = DEFAULT_DATABASE_NAME) {
  const dbPath = await getDatabasePath(dbName);

  const adapter = new SQLiteAdapter({
    schema,
    migrations,
    dbName: dbPath,
  });

  const instance = new Database({
    adapter,
    modelClasses,
    actionsEnabled: true,
  });
  instances[dbName] = instance;
  // sync();
  return db;
 }


 export const getDatabase = async (
  dbName: string = DEFAULT_DATABASE_NAME,
 ) => {
  if (!promises[dbName]) {
    promises[dbName] = init(dbName);
  }
  const instance = await promises[dbName];
  return instance;
 };

 // For _very_ specific uses
 export const getDatabaseSync = (altDbName: string = DEFAULT_DATABASE_NAME) => {
  return instances[altDbName];
 };

 // custom withDatabase to handle the possibility of not having the database just yet...
 export type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;

 export const withDatabase = <T extends DatabaseProp>(
  Wrapped: React.ComponentType<T>,
 ) => {
  const WrappedComponent: React.ComponentType<Omit<T, DatabaseProp>> = (
    props,
  ) => {
    const database = useDatabase();
    if (!database) {
      return <View />;
    }
    return <Wrapped {...(props as T)} database={database} />;
  };

  return WrappedComponent;
 };
diff --git a/WatermelonProvider.js b/WatermelonProvider.js
 import React, { ReactChild } from 'react';
 import { Database } from '@nozbe/watermelondb';
 import { getWatermelon } from 'app/utils/DBWatermelonOld/DBWatermelonOld';
 import DatabaseProvider from '@nozbe/watermelondb/DatabaseProvider';

 const WatermelonProvider = (props) => {
  const watermelonRef = React.useRef();
  const [database, setDatabase] = React.useState();

  if (!watermelonRef.current) {
    const promise = getWatermelon();
    if (promise) {
      watermelonRef.current = promise;
      watermelonRef.current.then(setDatabase);
    }
  }

  return database ? <DatabaseProvider database={database} {...props} /> : null;
 };

 export default WatermelonProvider;
	import RNFS from "react-native-fs";

	// Currently android will add `.db` to file name...
	async function getDatabasePath(dbName) {
	let dbPath = `${RNFS.DocumentDirectoryPath}/${dbName}`;

	const exists = await RNFS.exists(dbPath.concat(".db"));
	if (!exists) {
	try {
	await RNFS.copyFileAssets(dbName.concat(".db"), dbPath.concat(".db"));
	} catch (e) {
	console.log(">>> getDatabasePath error", e);
	}
	}

	return dbPath;
	}

	export default getDatabasePath;
	import RNFS from 'react-native-fs';
	import * as RNZIP from 'react-native-zip-archive

	async function getDatabasePath(dbName) {
	let sanitizedDbName = dbName;

	if (!sanitizedDbName.endsWith(".db")) {
	sanitizedDbName = sanitizedDbName.concat(".db");
	}

	let dbPath = `${RNFS.DocumentDirectoryPath}/${sanitizedDbName}`;

	const exists = await RNFS.exists(dbPath);
	if (!exists) {
	const assetPath = `${RNFS.MainBundlePath}/${sanitizedDbName.replace(
	".db",
	".zip"
	)}`;
	const existsZip = await RNFS.exists(assetPath);
	if (existsZip) {
	const tmpPath = `${RNFS.DocumentDirectoryPath}/tmp`;
	await RNZIP.unzip(assetPath, tmpPath);
	await RNFS.moveFile(`${tmpPath}/${sanitizedDbName}`, dbPath);
	await RNFS.unlink(tmpPath);
	}
	}
	return dbPath;
	}
	export default getDatabasePath;
	async function getDatabasePath(dbName) {
	let fullDbName = dbName;

	if (!fullDbName.endsWith('.db') && !fullDbName.includes('?')) {
	fullDbName = fullDbName.concat('.db');
	}

	let dbPath = dbName.includes(process.cwd())
	? fullDbName
	: `${process.cwd()}/${fullDbName}`;

	return dbPath;
	}

	export default getDatabasePath;
	import getDatabasePath from './getDatabasePath';

	const DEFAULT_DATABASE_NAME = 'watermelon';

	const promises: { [key: string]: Promise<Database> } = {};
	const instances: { [key: string]: Database } = {};

	async function init(dbName: string = DEFAULT_DATABASE_NAME) {
	const dbPath = await getDatabasePath(dbName);

	const adapter = new SQLiteAdapter({
	schema,
	migrations,
	dbName: dbPath,
	});

	const instance = new Database({
	adapter,
	modelClasses,
	actionsEnabled: true,
	});
	instances[dbName] = instance;
	// sync();
	return db;
	}


	export const getDatabase = async (
	dbName: string = DEFAULT_DATABASE_NAME,
	) => {
	if (!promises[dbName]) {
	promises[dbName] = init(dbName);
	}
	const instance = await promises[dbName];
	return instance;
	};

	// For _very_ specific uses
	export const getDatabaseSync = (altDbName: string = DEFAULT_DATABASE_NAME) => {
	return instances[altDbName];
	};

	// custom withDatabase to handle the possibility of not having the database just yet...
	export type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;

	export const withDatabase = <T extends DatabaseProp>(
	Wrapped: React.ComponentType<T>,
	) => {
	const WrappedComponent: React.ComponentType<Omit<T, DatabaseProp>> = (
	props,
	) => {
	const database = useDatabase();
	if (!database) {
	return <View />;
	}
	return <Wrapped {...(props as T)} database={database} />;
	};

	return WrappedComponent;
	};
	import React, { ReactChild } from 'react';
	import { Database } from '@nozbe/watermelondb';
	import { getWatermelon } from 'app/utils/DBWatermelonOld/DBWatermelonOld';
	import DatabaseProvider from '@nozbe/watermelondb/DatabaseProvider';

	const WatermelonProvider = (props) => {
	const watermelonRef = React.useRef();
	const [database, setDatabase] = React.useState();

	if (!watermelonRef.current) {
	const promise = getWatermelon();
	if (promise) {
	watermelonRef.current = promise;
	watermelonRef.current.then(setDatabase);
	}
	}

	return database ? <DatabaseProvider database={database} {...props} /> : null;
	};

	export default WatermelonProvider;