Error: "xcodebuild redefinition of 'sqlite3_xxx'" when building fresh expo project

[felixsebastian]

Problem

Can't build expo app, get a bunch of errors like

❌  (ios/Pods/Headers/Public/react-native-quick-sqlite/sqlite3.h:723:8)

  721 | */
  722 | typedef struct sqlite3_file sqlite3_file;
> 723 | struct sqlite3_file {
      |        ^ redefinition of 'sqlite3_file'
  724 |   const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
  725 | };
  726 |

Also get a warning when I run expo-doctor about this package being 'Untested on New Architecture'

Steps to reproduce

1. create an expo app with npx create-expo-app
2. install with npx expo install @journeyapps/react-native-quick-sqlite
3. Try and build the project with npx expo run:ios

[histefhere]

Having this problem as well when using eas build

[mugikhan]

Hey @felixsebastian and @histefhere
This issue is caused by multiple versions of SQLite3 being included in your project, which happens because expo-updates also depends on SQLite. The solution is to enable the third-party SQLite pod for expo-updates.
To fix this, update your ios/Podfile.properties.json to include the following configuration:

{
  "expo.updates.useThirdPartySQLitePod": "true"
}

For more details, you can refer to the discussion in Expo issue #30546.

Let us know if this works for you.

[DeliveranceTechSolutions]

I'm confused because I see the original developer list the fix as:

expo.updates.use3rdPartySQLitePod: "true" via 30826

Is the correct syntax what you have provided @mugikhan ?

My issue pertains to an error starting with

` 37 | #include <regex.h>
38 |

39 | static void sqlite_regexp(sqlite3_context* context, int argc, sqlite3_value** values) {
| ^ unknown type name 'sqlite3_context'; did you mean 'exsqlite3_context'?
40 | if ( argc < 2 ) {
41 | sqlite3_result_error(context, "SQL function regexp() called with missing arguments.", -1);
42 | return;`

Platform: ios

Target OS: 15.1

I reinstalled pods, changed configs, took out any db interactions I had, etc. however, I still come to the same problem.

It's actually a problem with react-native-sqlite-storage; however, I'm guessing that's common knowledge?

[mugikhan]

@DeliveranceTechSolutions My statement is correct, I have tested it personally and it works. It also aligns with what is currently in the Expo package See here.

Is there any other packages you are using that could be providing sqlite3 maybe expo-sqlite?
You can also try cleaning the expo build (rm -rf .expo) and rerunning the build.

[histefhere]

After running prebuild I added {
"expo.updates.useThirdPartySQLitePod": "true"
} to ios/Podfile.properties.json, and then after that I ran npx expo run:ios, which successfully build the app on the simulator. However when I then run an EAS build I still get this error:

Build failed: The "Run fastlane" step failed because of an error in the Xcode build process. We automatically detected following errors in your Xcode build logs:
redefinition of 'sqlite3_file'
redefinition of 'sqlite3_io_methods'
redefinition of 'sqlite3_vfs'
redefinition of 'sqlite3_mem_methods'
conflicting types for 'sqlite3_create_filename'
conflicting types for 'sqlite3_free_filename'
redefinition of 'sqlite3_module'
redefinition of 'sqlite3_index_info'
redefinition of 'sqlite3_index_constraint'
redefinition of 'sqlite3_index_orderby'
redefinition of 'sqlite3_index_constraint_usage'
redefinition of 'sqlite3_vtab'
redefinition of 'sqlite3_vtab_cursor'
redefinition of 'sqlite3_mutex_methods'
redefinition of 'sqlite3_pcache_page'
redefinition of 'sqlite3_pcache_methods2'
redefinition of 'sqlite3_pcache_methods'
redefinition of 'sqlite3_snapshot'
typedef redefinition with different types ('struct (unnamed struct at /Users/expo/workingdir/build/ios/Pods/Headers/Public/react-native-quick-sqlite/sqlite3.h:10109:16)' vs 'struct sqlite3_snapshot')
could not build Objective-C module 'SQLite3'
Refer to "Xcode Logs" below for additional, more detailed logs.

[stevensJourney]

I tested this locally and on EAS build. Adding my findings here for context.

I ran the following to create a fresh app.

npx create-expo-app
npx expo install @journeyapps/react-native-quick-sqlite
npx expo run:ios

For me this did not give any errors. The app launched after building. Since this issue is related to multiple definitions of SQLite, I manually added expo-updates with npx expo install expo-updates. I could then reproduce the issue.

I followed the steps recommended by Mugi of adding the settings to my /ios/Podfile.properties.json file and the build then succeeded locally. I then triggered an EAS build with eas build -p ios --profile preview which also succeeded.

For some background: It seems like expo-updates will use the system version of SQLite now by default. If the system SQLite3 library is used in conjunction with React Native Quick SQLite then these redefinition of ... errors will be present. Setting expo.updates.use3rdPartySQLitePod: "true" will cause expo-updates to instead install the sqlite3 pod dependency. This still technically results in multiple versions of SQLite being present in the project, which is not ideal, but with the default project linking settings this seems to be less error prone than using the system version. If using frameworks with static linking other issues may still arise.

@histefhere I'd start by verifying the ios folder and Podfile.properties.json files are not added to any gitignore of easignore entries. Otherwise could you share a minimal reproducible example repo?

[G2Jose]

Here's what I had to do to get powersync working with expo 52:

1. Update Podfile.properties.json

 {
-  "ios.deploymentTarget": "15.5"
+  "ios.deploymentTarget": "15.5",
+  "expo.updates.useThirdPartySQLitePod": "true"
 }

2. Update Podfile with a pre_install step:

puts "config_command: #{config_command}"

+  pre_install do |installer|
+    installer.pod_targets.each do |pod|
+      next unless pod.name.eql?('react-native-quick-sqlite')
+
+      def pod.build_type
+        Pod::BuildType.static_library
+      end
+    end
+  end
+
config = use_native_modules!(config_command)

3. Update @journeyapps/react-native-quick-sqlite in package.json

-    "@journeyapps/react-native-quick-sqlite": "^1.4.0",
+    "@journeyapps/react-native-quick-sqlite": "^2.2.1",

[maitriyogin]

I created a config plugin for this:

/**
 * This updates the podfile.properties.json
 */
const { withPodfileProperties } = require("@expo/config-plugins");

const withCustomConfig = (config, id) => {
  return withPodfileProperties(config, (config) => {
    config.modResults["expo.updates.useThirdPartySQLitePod"] = "true";
    return config;
  });
};
module.exports = withCustomConfig;

and then in your app.json

"plugins":[["./plugins/withCustomConfig"]],

put it in a plugins/ directory in you app root ...

Works like a dream (-:

/Stephen.

[smontlouis]

Thank you !

[liolocs]

You're a legend

[kevinschaich]

Thanks so much!!

You can use this directly in app.config.ts like so:

import { withPodfileProperties } from '@expo/config-plugins'
import { ConfigContext, ExpoConfig } from 'expo/config'

const withCustomConfig = (config, id) => {
    return withPodfileProperties(config, config => {
        config.modResults['expo.updates.useThirdPartySQLitePod'] = 'true'
        return config
    })
}

export default ({ config }: ConfigContext): ExpoConfig => ({
    ...config,
    plugins: [ withCustomConfig as any ],
})

[aguilaair]

@stevensJourney, imo you should mark this as the appropriate solution, as it maintains an Expo-managed workflow :)

[stevensJourney]

The custom config plugin which enables useThirdPartySQLitePod looks great to me.

Also note that #79 (released in version 2.4.5) added an Expo Config plugin to this package which can be used to configure the static library build type.

I'm not entirely sure about the exact circumstances when useThirdPartySQLitePod is required, if useful, we could add this config method to our Expo config plugin.

[felixsebastian]

for anyone who also needs the pre_install code that @G2Jose posted and doesn't want to eject

/* eslint-disable */
const { withDangerousMod } = require("@expo/config-plugins");
const fs = require("fs");
const path = require("path");

/**
 * Expo config plugin to configure op-sqlite as static library
 * This fixes SQLite redefinition conflicts by:
 * 1. Making expo-updates use third-party SQLite pod
 * 2. Configuring op-sqlite as static library
 * Based on G2Jose's solution: https://github.com/powersync-ja/react-native-quick-sqlite/discussions/70
 */
function withSQLiteStaticLibrary(config) {
  return withDangerousMod(config, [
    "ios",
    async (config) => {
      const podfilePath = path.join(
        config.modRequest.platformProjectRoot,
        "Podfile",
      );
      const podfilePropertiesPath = path.join(
        config.modRequest.platformProjectRoot,
        "Podfile.properties.json",
      );

      // 1. Update Podfile.properties.json to use third-party SQLite pod
      if (fs.existsSync(podfilePropertiesPath)) {
        let podfileProperties = JSON.parse(fs.readFileSync(podfilePropertiesPath, "utf8"));
        
        // Add the useThirdPartySQLitePod setting
        podfileProperties["expo.updates.useThirdPartySQLitePod"] = "true";
        
        fs.writeFileSync(podfilePropertiesPath, JSON.stringify(podfileProperties, null, 2));
      }

      // 2. Add pre_install hook to configure op-sqlite as static library
      if (fs.existsSync(podfilePath)) {
        let podfileContent = fs.readFileSync(podfilePath, "utf8");

        // Check if our pre_install hook is already present
        if (!podfileContent.includes("Fix for SQLite conflicts")) {
          // Find the target insertion point (after prepare_react_native_project!)
          const insertionPoint = "prepare_react_native_project!";
          const insertionIndex = podfileContent.indexOf(insertionPoint);

          if (insertionIndex !== -1) {
            const endOfLine = podfileContent.indexOf("\n", insertionIndex) + 1;

            const preInstallHook = `
# Fix for SQLite conflicts: Configure op-sqlite as static library
pre_install do |installer|
  installer.pod_targets.each do |pod|
    if pod.name.eql?('op-sqlite')
      def pod.build_type
        Pod::BuildType.static_library
      end
    end
  end
end
`;

            podfileContent =
              podfileContent.slice(0, endOfLine) +
              preInstallHook +
              podfileContent.slice(endOfLine);

            fs.writeFileSync(podfilePath, podfileContent);
          }
        }
      }

      return config;
    },
  ]);
}

module.exports = withSQLiteStaticLibrary;

add "./plugins/withSQLiteStaticLibrary.js" to expo.plugins in app.json