@advenue/react-native 0.9.0 → 1.0.0

package/scripts/check-dist.mjs

@@ -24,6 +24,23 @@ for (const mod of ['expo-modules-core', 'react-native']) {
   }
 }
 
+// The published package must be self-contained. It imports no workspace code
+// at all now, so the check is the general one rather than a list of the private
+// packages that used to need inlining: ANY surviving @advenue/* import breaks
+// `npm install @advenue/react-native` outside the monorepo.
+for (const file of ['../dist/index.js', '../dist/index.cjs']) {
+  const bundle = readFileSync(fileURLToPath(new URL(file, import.meta.url)), 'utf8');
+  // Covers every specifier position esbuild can emit: `from "x"`, a bare
+  // side-effect `import "x"`, and `require("x")`. A pattern that only knew
+  // `from` would pass a bundle that still pulls in a workspace package.
+  const found = bundle.match(/(?:from\s*["']|\bimport\s*["']|require\(\s*["'])(@advenue\/[\w-]+)/);
+  if (found) {
+    problems.push(
+      `${file} imports ${found[1]} — the published package must import no workspace code`,
+    );
+  }
+}
+
 if (problems.length > 0) {
   console.error(`check-dist failed:\n- ${problems.join('\n- ')}`);
   process.exit(1);

package/scripts/check-vendored-swift.mjs

@@ -0,0 +1,148 @@
+// Compiles the vendored Swift tree the way CocoaPods will: as ONE module.
+//
+// This is the check whose absence let a non-building package onto main. The
+// Swift SDK is three SwiftPM modules that import each other; the podspec globs
+// all of their sources into a single pod target, where `import AdvenueCore`
+// names a module that does not exist. Nothing caught it, because the Expo
+// module compiles only inside a host app and no host app is built here.
+//
+// A whole host app is not needed to catch it. `swiftc -emit-module` over the
+// vendored sources reproduces exactly the condition that broke — one module,
+// same deployment target — and needs neither Xcode projects nor
+// ExpoModulesCore. What it does NOT cover is `AdvenueIosModule.swift` itself,
+// which does need ExpoModulesCore; that gap is real and stays.
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+/** iOS deployment target — must match `s.platforms` in the podspec. */
+const DEPLOYMENT_TARGET = '15.1';
+
+function swiftFiles(dir) {
+  if (!existsSync(dir)) return [];
+  let out = [];
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    if (statSync(path).isDirectory()) out = out.concat(swiftFiles(path));
+    else if (entry.endsWith('.swift')) out.push(path);
+  }
+  return out;
+}
+
+/** The SDK's own SwiftPM module names, which do not survive flattening. */
+const SDK_MODULES = ['Advenue', 'AdvenueCore', 'AdvenuePlatform', 'AdvenueFirebase'];
+
+/**
+ * Compiled by name, not by directory, unlike `AdvenueIosModule.swift`: that
+ * file is excluded from this compile step simply by living outside
+ * `vendorDir`. The Flutter plugin has no such sibling location — Flutter's
+ * fixed Kotlin/Swift layout puts it INSIDE the vendored tree, because both
+ * packaging systems compile that directory as one module — so it has to be
+ * excluded here explicitly. It `import Flutter`, a framework only a host-app
+ * build provides, and failing to compile it here is not a defect: the same
+ * gap that already excuses `AdvenueIosModule.swift` (which needs
+ * ExpoModulesCore) applies to it too. The text import check below still
+ * covers it — that is what would catch a genuine `import Advenue`.
+ */
+const EXCLUDED_FROM_COMPILE = ['AdvenueFlutterPlugin.swift'];
+
+/**
+ * No file in `ios/` may import one of the SDK's own modules.
+ *
+ * The compile check below covers `ios/vendor`, but not `AdvenueIosModule.swift`
+ * — that one needs ExpoModulesCore and cannot be compiled here. It lands in the
+ * same pod target all the same, so the same import kills the build there. A
+ * text check reaches where the compiler cannot.
+ */
+export function checkNoSdkImports({ root = packageRoot, vendorDir = 'ios/vendor' } = {}) {
+  const pattern = new RegExp(`^\\s*import\\s+(${SDK_MODULES.join('|')})\\s*$`, 'm');
+  const offenders = [];
+  for (const file of swiftFiles(join(root, vendorDir, '..'))) {
+    const match = pattern.exec(readFileSync(file, 'utf8'));
+    if (match) offenders.push(`${file.replace(`${root}/`, '')} imports ${match[1]}`);
+  }
+  return offenders;
+}
+
+export function checkVendoredSwift({ root = packageRoot, vendorDir = 'ios/vendor' } = {}) {
+  const offenders = checkNoSdkImports({ root, vendorDir });
+  if (offenders.length > 0) {
+    return {
+      ok: false,
+      error: `these files import a module the pod does not have:\n${offenders.join('\n')}`,
+    };
+  }
+
+  if (process.platform !== 'darwin') {
+    return { ok: true, skipped: 'not macOS — the Swift toolchain is unavailable here' };
+  }
+
+  const sources = swiftFiles(join(root, vendorDir)).filter(
+    (file) => !EXCLUDED_FROM_COMPILE.some((name) => file.endsWith(`/${name}`)),
+  );
+  if (sources.length === 0) {
+    return { ok: false, error: 'no vendored Swift sources — run the vendor step first' };
+  }
+
+  let sdk;
+  try {
+    sdk = execFileSync('xcrun', ['--sdk', 'iphonesimulator', '--show-sdk-path'], {
+      encoding: 'utf8',
+    }).trim();
+  } catch {
+    return { ok: true, skipped: 'no iOS SDK installed — Xcode command line tools are absent' };
+  }
+
+  // A real directory, not /dev/null: -emit-module writes .swiftdoc,
+  // .swiftsourceinfo and .abi.json alongside the module, and those siblings
+  // cannot be opened next to a device file.
+  const out = mkdtempSync(join(tmpdir(), 'advenue-swiftcheck-'));
+  try {
+    execFileSync(
+      'xcrun',
+      [
+        'swiftc',
+        '-sdk',
+        sdk,
+        '-target',
+        `arm64-apple-ios${DEPLOYMENT_TARGET}-simulator`,
+        '-module-name',
+        'AdvenueIos',
+        '-emit-module',
+        '-o',
+        join(out, 'AdvenueIos.swiftmodule'),
+        ...sources,
+      ],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
+    );
+  } catch (failure) {
+    const output = `${failure.stderr ?? ''}${failure.stdout ?? ''}`;
+    const errors = output
+      .split('\n')
+      .filter((line) => line.includes('error:'))
+      .slice(0, 10)
+      .join('\n');
+    return { ok: false, count: sources.length, error: errors || output.slice(0, 2000) };
+  } finally {
+    rmSync(out, { recursive: true, force: true });
+  }
+
+  return { ok: true, count: sources.length };
+}
+
+if (process.argv[1]?.endsWith('check-vendored-swift.mjs')) {
+  const result = checkVendoredSwift();
+  if (!result.ok) {
+    console.error(`vendored Swift does not compile as one module:\n${result.error}`);
+    process.exit(1);
+  }
+  console.log(
+    result.skipped
+      ? `check-vendored-swift skipped: ${result.skipped}`
+      : `check-vendored-swift ok: ${result.count} sources compile as one module`,
+  );
+}

package/scripts/vendor-natives.mjs

@@ -0,0 +1,149 @@
+// Copies the native SDK sources into this package so the npm tarball carries
+// them. The monorepo copy is the source of truth; the copies here are build
+// output and are gitignored, because a checked-in duplicate drifts and nobody
+// notices until a fix lands in one of them.
+//
+// The counting is not decoration. A copy step that silently copies nothing
+// ships an SDK with no native code: it installs, it links, it does nothing, and
+// nothing errors. That is the worst failure available, so this refuses to
+// succeed quietly.
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const monorepo = resolve(packageRoot, '../..');
+
+/** Every file under `dir`, recursively, matching one of `extensions`. */
+function countSources(dir, extensions) {
+  if (!existsSync(dir)) return 0;
+  let total = 0;
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    if (statSync(path).isDirectory()) total += countSources(path, extensions);
+    else if (extensions.some((ext) => entry.endsWith(ext))) total += 1;
+  }
+  return total;
+}
+
+/**
+ * The Android plugin modules whose sources must travel with the base SDK.
+ *
+ * The SDK resolves these by fixed class name with `Class.forName`, so a plugin
+ * that is not in the package resolves to null — silently, because an absent
+ * plugin is the ordinary case for a native app that did not ask for it. Leaving
+ * them behind therefore produced no error and no log: just an Android SDK with
+ * no Play Install Referrer, reporting paid installs as organic.
+ *
+ * `plugin-firebase` is deliberately absent and `plugin-firebase-reflect` takes
+ * its place: the typed one imports firebase-analytics, and adding that
+ * dependency would force Firebase on every React Native app. The reflect
+ * variant declares the same class name and reaches Firebase only if the host
+ * app already ships it. The two are never on one classpath, because a wrapper
+ * app has no way to add the Maven artifact.
+ */
+const ANDROID_PLUGINS = [
+  'plugin-play-referrer',
+  'plugin-play-identity',
+  'plugin-play-integrity',
+  'plugin-firebase-reflect',
+];
+
+/**
+ * The SwiftPM modules the SDK is split into. They import each other, and the
+ * podspec globs all of their sources into ONE pod target — where those imports
+ * name modules that do not exist.
+ *
+ * So the imports are stripped on the way in. They are meaningful only in the
+ * SwiftPM distribution; in the flattened one every symbol is already in scope,
+ * and `internal` is module-scoped, so flattening makes things MORE visible
+ * rather than less. The only thing it could break is a name collision between
+ * two modules, and the compiler says so — which is why the vendored tree is
+ * compiled as one module by `check-vendored-swift.mjs` rather than trusted.
+ */
+const SWIFT_MODULES = ['Advenue', 'AdvenueCore', 'AdvenuePlatform', 'AdvenueFirebase'];
+
+/** Removes intra-SDK imports from every vendored Swift file. */
+function flattenSwiftModules(dir) {
+  const pattern = new RegExp(`^\\s*import\\s+(?:${SWIFT_MODULES.join('|')})\\s*$\\n?`, 'gm');
+  let stripped = 0;
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    if (statSync(path).isDirectory()) {
+      stripped += flattenSwiftModules(path);
+      continue;
+    }
+    if (!entry.endsWith('.swift')) continue;
+    const source = readFileSync(path, 'utf8');
+    const flattened = source.replace(pattern, '');
+    if (flattened !== source) {
+      writeFileSync(path, flattened);
+      stripped += 1;
+    }
+  }
+  return stripped;
+}
+
+export function vendor({ swiftFrom, kotlinFrom, into, layout } = {}) {
+  const swiftSource = swiftFrom ?? resolve(monorepo, 'packages/sdk-swift/Sources');
+  const kotlinSource = kotlinFrom ?? resolve(monorepo, 'packages/sdk-android/sdk/src/main/kotlin');
+  const target = into ?? packageRoot;
+
+  // Where each wrapper wants the sources. React Native's layout is the default
+  // so this change moves nothing; Flutter passes its own, because its iOS path
+  // is fixed by Flutter's Swift Package Manager structure rather than by us.
+  const swiftTarget = join(target, layout?.swift ?? 'ios/vendor');
+  const kotlinTarget = join(target, layout?.kotlin ?? 'android/src/main/kotlin');
+
+  for (const dir of [swiftTarget, kotlinTarget]) {
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+  }
+
+  if (existsSync(swiftSource)) cpSync(swiftSource, swiftTarget, { recursive: true });
+  if (existsSync(kotlinSource)) cpSync(kotlinSource, kotlinTarget, { recursive: true });
+
+  // The plugin modules merge into the same package tree the base SDK occupies,
+  // which is exactly what the fixed-name lookup expects to find.
+  if (kotlinFrom === undefined) {
+    for (const plugin of ANDROID_PLUGINS) {
+      const source = resolve(monorepo, `packages/sdk-android/${plugin}/src/main/kotlin`);
+      if (existsSync(source)) cpSync(source, kotlinTarget, { recursive: true });
+    }
+  }
+
+  if (existsSync(swiftTarget)) flattenSwiftModules(swiftTarget);
+
+  const swift = countSources(swiftTarget, ['.swift']);
+  const kotlin = countSources(kotlinTarget, ['.kt']);
+
+  if (swift === 0 || kotlin === 0) {
+    return {
+      ok: false,
+      swift,
+      kotlin,
+      error: `vendoring copied no files (swift=${swift}, kotlin=${kotlin}). Shipping this package would install an SDK with no native code.`,
+    };
+  }
+  return { ok: true, swift, kotlin };
+}
+
+// Run directly: report and fail loudly.
+if (process.argv[1]?.endsWith('vendor-natives.mjs')) {
+  const result = vendor();
+  if (!result.ok) {
+    console.error(result.error);
+    process.exit(1);
+  }
+  console.log(`vendored ${result.swift} Swift and ${result.kotlin} Kotlin sources`);
+}

package/scripts/vendor-natives.test.mjs

@@ -0,0 +1,112 @@
+import assert from 'node:assert/strict';
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+/** Every .kt file under `dir`, recursively; an absent dir yields none. */
+function kotlinFiles(dir) {
+  let out = [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const path = join(dir, entry);
+    if (statSync(path).isDirectory()) out = out.concat(kotlinFiles(path));
+    else if (entry.endsWith('.kt')) out.push(path);
+  }
+  return out;
+}
+import { test } from 'node:test';
+import { vendor } from './vendor-natives.mjs';
+
+/**
+ * A copy step that silently copies nothing ships an SDK with no native code:
+ * it installs, it links, it does nothing, and nothing errors. That is the
+ * failure this refuses to allow, so it is the first thing asserted.
+ */
+test('refuses an empty result rather than succeeding quietly', () => {
+  const empty = mkdtempSync(join(tmpdir(), 'advenue-empty-'));
+  const target = mkdtempSync(join(tmpdir(), 'advenue-target-'));
+
+  const result = vendor({ swiftFrom: empty, kotlinFrom: empty, into: target });
+
+  assert.equal(result.ok, false);
+  assert.match(result.error, /copied no files/);
+  assert.match(result.error, /no native code/);
+});
+
+test('copies the real SDK sources and counts them', () => {
+  const target = mkdtempSync(join(tmpdir(), 'advenue-target-'));
+  const result = vendor({ into: target });
+
+  assert.equal(result.ok, true, result.error);
+  assert.ok(result.swift > 20, `expected the Swift SDK's sources, got ${result.swift}`);
+  assert.ok(result.kotlin > 15, `expected the Kotlin SDK's sources, got ${result.kotlin}`);
+});
+
+test('a partial source tree is still a failure', () => {
+  const swiftOnly = mkdtempSync(join(tmpdir(), 'advenue-swift-'));
+  mkdirSync(join(swiftOnly, 'Core'), { recursive: true });
+  writeFileSync(join(swiftOnly, 'Core/A.swift'), '// source');
+  const empty = mkdtempSync(join(tmpdir(), 'advenue-empty-'));
+  const target = mkdtempSync(join(tmpdir(), 'advenue-target-'));
+
+  const result = vendor({ swiftFrom: swiftOnly, kotlinFrom: empty, into: target });
+
+  assert.equal(result.ok, false, 'one platform missing is still a broken package');
+  assert.equal(result.swift, 1);
+  assert.equal(result.kotlin, 0);
+});
+
+/**
+ * Every plugin class the SDK looks up by name must exist in this package.
+ *
+ * This is the check that was missing, and its absence shipped an outage. The
+ * Android SDK resolves its enrichment plugins with `Class.forName` against
+ * fixed names in `PluginRegistry`; the implementations live in separate Gradle
+ * modules that the vendoring did not copy. So `Class.forName` returned null for
+ * all four, silently, and an app built on the React Native SDK had no Play
+ * Install Referrer — Android's primary deterministic attribution signal, whose
+ * absence reports paid installs as organic.
+ *
+ * Counting files cannot catch that: the count was right and the package was
+ * still broken. What catches it is asking whether what was copied is
+ * SUFFICIENT, which is what this asserts.
+ */
+test('every plugin class the registry looks up is present in the package', () => {
+  const target = mkdtempSync(join(tmpdir(), 'advenue-target-'));
+  const result = vendor({ into: target });
+  assert.equal(result.ok, true, result.error);
+
+  const registry = readFileSync(
+    join(target, 'android/src/main/kotlin/io/advenue/plugin/PluginRegistry.kt'),
+    'utf8',
+  );
+  const expected = [...registry.matchAll(/"(io\.advenue\.plugin\.\w+)"/g)].map((m) => m[1]);
+  assert.ok(expected.length >= 4, `expected the registry's plugin names, got ${expected.length}`);
+
+  const declared = new Set();
+  for (const root of [join(target, 'android/src/main/kotlin'), 'android/src/main/java']) {
+    for (const file of kotlinFiles(root)) {
+      const source = readFileSync(file, 'utf8');
+      const pkg = /^package\s+([\w.]+)/m.exec(source)?.[1];
+      if (!pkg) continue;
+      for (const [, name] of source.matchAll(/^(?:public |internal )?(?:class|object)\s+(\w+)/gm)) {
+        declared.add(`${pkg}.${name}`);
+      }
+    }
+  }
+
+  const missing = expected.filter((name) => !declared.has(name));
+  assert.deepEqual(missing, [], 'a plugin the SDK looks up by name is not in the package');
+});

package/src/deep-links.ts

@@ -1,4 +1,21 @@
-import type { DeepLink } from '@advenue/sdk-core';
+import type { DeepLink } from './types';
+
+/**
+ * M3: `params`'a kopyalanmasına izin verilen query anahtarları.
+ *
+ * `parseDirectLink` eskiden tüm query dizgesini kopyalıyordu (`?email=…&phone=…`
+ * gibi PII taşıyan anahtarlar dahil). Ham `url` aynen korunur (uygulama kendi
+ * yönlendirmesi için kendisi ayrıştırabilir), ancak `params` yalnızca
+ * attribution/yönlendirme için güvenli olduğu bilinen anahtarları taşır.
+ */
+const ALLOWED_QUERY_KEYS = new Set([
+  'ref',
+  'campaign',
+  'network',
+  'influencer_id',
+  'influencerId',
+  'al_applink_data',
+]);
 
 /** Handle for tearing down the OS deep-link listener. */
 export interface DeepLinkSubscription {
@@ -32,6 +49,7 @@ export function parseDirectLink(url: string): DeepLink {
     // lib.dom.iterable / @types/node, neither of which is guaranteed in the
     // dts build's lib set — forEach is in the base lib everywhere.
     parsed.searchParams.forEach((v, k) => {
+      if (!ALLOWED_QUERY_KEYS.has(k)) return;
       params ??= {};
       params[k] = v;
     });