lecodes-cli 2.2.6 → 2.2.9

package/src/plugin/emitPackage.ts

@@ -0,0 +1,98 @@
+// A plugin repo's `Package.swift`, from the manifests: the plugins with an iOS half as ONE SwiftPM
+// package — a target per plugin (its sources `plugins/<id>/ios`, the packages its manifest names)
+// and a product per plugin. Each plugin is its own MODULE, so two plugins may declare a type of the
+// same name, and an Xcode project links a plugin as a product instead of compiling its folder.
+//
+// The targets depend on the LeCodes SDK as a package on disk: `LECODES_IOS_SDK_PATH`, else the path
+// the repo's package.json names (`lecodes.iosSdkPath`), else the sibling `../lecodes` (a checkout
+// of the published SDK package, or whatever stands there).
+//
+// A shell made by `lecodes app sync` does NOT use this package: it vendors the sources into targets
+// of its own (templates/ios.ts), pinned by plugins.lock.json.
+
+import type { PluginManifest } from "./manifest"
+import { pascal } from "./manifest"
+
+export class PackageError extends Error {}
+
+/** A package's identity from its URL (`https://github.com/stasel/WebRTC` → `WebRTC`): what SwiftPM
+ *  names it in `.product(name:package:)`. The same rule as the shell's (commands/app/shared.ts). */
+export const swiftPackageName = (url: string): string =>
+  (url.replace(/\/+$/, "").split("/").pop() ?? url).replace(/\.git$/, "")
+
+/** The Swift module of a plugin's iOS half: the manifest's, or `LeCodes` + the id in PascalCase. */
+export const iosModule = (id: string, manifest: PluginManifest): string => manifest.ios?.module ?? `LeCodes${pascal(id)}`
+
+export const PACKAGE_FILE = "Package.swift"
+
+/** Where the SDK package stands when neither the environment nor the repo says: a sibling checkout. */
+export const DEFAULT_SDK_PATH = "../lecodes"
+
+/** The text of the repo's Package.swift for `plugins` (every manifest; those without an iOS half are
+ *  left out); `sdkPath` is the repo's own SDK location (package.json `lecodes.iosSdkPath`). Throws
+ *  PackageError when two plugins pin one package at different versions. */
+export const emitPackageSwift = (plugins: { id: string, manifest: PluginManifest }[], sdkPath: string = DEFAULT_SDK_PATH): string => {
+  const ios = plugins.filter(p => p.manifest.ios !== null)
+  const packages = new Map<string, { url: string, exact?: string, from?: string, by: string }>()
+  for (const p of ios) {
+    for (const pkg of p.manifest.ios!.packages ?? []) {
+      const prior = packages.get(pkg.url)
+      if (prior && (prior.exact !== pkg.exact || prior.from !== pkg.from)) {
+        throw new PackageError(`"${p.id}" pins ${pkg.url} at ${pkg.exact ?? `from ${pkg.from}`} but "${prior.by}" pins ${prior.exact ?? `from ${prior.from}`} — one package resolves once`)
+      }
+      if (!prior) packages.set(pkg.url, { ...pkg, by: p.id })
+    }
+  }
+  const moduleOf = (p: { id: string, manifest: PluginManifest }) => iosModule(p.id, p.manifest)
+
+  const products = ios.map(p => `        .library(name: "${moduleOf(p)}", targets: ["${moduleOf(p)}"]),`)
+  const dependencies = [
+    `        .package(name: "lecodes", path: sdk),`,
+    ...[...packages.values()].map(pkg => `        .package(url: "${pkg.url}", ${pkg.exact ? `exact: "${pkg.exact}"` : `from: "${pkg.from}"`}),`),
+  ]
+  const targets = ios.map(p => {
+    const deps = [
+      `.product(name: "LeCodes", package: "lecodes")`,
+      ...(p.manifest.ios!.packages ?? []).flatMap(pkg => pkg.products.map(name => `.product(name: "${name}", package: "${swiftPackageName(pkg.url)}")`)),
+    ]
+    return [
+      `        // ${p.id}`,
+      `        .target(`,
+      `            name: "${moduleOf(p)}",`,
+      `            dependencies: [${deps.join(", ")}],`,
+      `            path: "plugins/${p.id}/ios"`,
+      `        ),`,
+    ].join("\n")
+  })
+
+  return `// swift-tools-version:5.9
+// GENERATED by \`lecodes plugin gen\` from the plugins' manifests (lecodes-plugin.json) — do not edit.
+//
+// The plugins with an iOS half as ONE SwiftPM package: a target per plugin (its sources in
+// plugins/<id>/ios, the packages its manifest names) and a product per plugin. Each plugin is its
+// own module: an Xcode project links a plugin as a product instead of compiling its folder, and two
+// plugins may name a type alike.
+//
+// The SDK is the LeCodes package on disk: LECODES_IOS_SDK_PATH, else the path below (the repo's
+// package.json \`lecodes.iosSdkPath\`, or the sibling ../lecodes). A shell made by \`lecodes app sync\`
+// does not use this package: it vendors the sources into targets of its own, pinned by
+// plugins.lock.json.
+import PackageDescription
+
+let sdk = Context.environment["LECODES_IOS_SDK_PATH"] ?? ${JSON.stringify(sdkPath)}
+
+let package = Package(
+    name: "lecodes-plugins",
+    platforms: [.iOS(.v15)],
+    products: [
+${products.join("\n")}
+    ],
+    dependencies: [
+${dependencies.join("\n")}
+    ],
+    targets: [
+${targets.join("\n")}
+    ]
+)
+`
+}

package/src/plugin/generate.ts

@@ -2,7 +2,8 @@
 // with a `contract.d.ts`; the path is one plugin, or a repo that keeps them in `plugins/<id>/`.
 // Generated files are written beside the hand-written ones of the place they travel to
 // (`sdk/<id>.gen.ts`, `ios/<Name>.gen.swift`, `android/…/<Name>.gen.kt`, `web/<id>.gen.ts`) and are
-// committed — `check` is what CI runs.
+// committed — `check` is what CI runs. A REPO of plugins also gets its `Package.swift` (the iOS
+// halves as one SwiftPM package, emitPackage.ts) from the manifests.
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs"
 import { createRequire } from "node:module"
@@ -15,7 +16,8 @@ import { EmitError, emitSdk } from "./emitSdk"
 import { emitSwift } from "./emitSwift"
 import { emitWeb } from "./emitWeb"
 import { lower } from "./lower"
-import { ManifestError, readManifestIfAny } from "./manifest"
+import { ManifestError, readManifestIfAny, type PluginManifest } from "./manifest"
+import { DEFAULT_SDK_PATH, PACKAGE_FILE, PackageError, emitPackageSwift } from "./emitPackage"
 
 // A path as the report shows it: relative to `from`, with `/` on every platform (a report is
 // compared and pasted; `\` is Windows' own).
@@ -52,12 +54,12 @@ export const loadTypescript = (dir: string): typeof tsModule => {
 export type Generated = { file: string, text: string }
 
 /** Everything one plugin's contract generates, as `path → text`. Throws ContractError / EmitError. */
-export const generatePlugin = (ts: typeof tsModule, plugin: PluginDir): { contract: Contract, files: Generated[] } => {
+export const generatePlugin = (ts: typeof tsModule, plugin: PluginDir): { contract: Contract, manifest: PluginManifest | null, files: Generated[] } => {
   const file = join(plugin.dir, CONTRACT_FILE)
   const contract = readContract(ts, file, readFileSync(file, "utf8"))
   // The manifest is held to the folders the plugin has: a half the manifest does not name is built
   // into no host.
-  readManifestIfAny(plugin.dir, plugin.id)
+  const manifest = readManifestIfAny(plugin.dir, plugin.id)
   const handWritten = existsSync(join(plugin.dir, "sdk", `${plugin.id}.ts`))
   const single = contract.channels.length === 1
   const files: Generated[] = contract.channels.map(channel => ({
@@ -81,7 +83,7 @@ export const generatePlugin = (ts: typeof tsModule, plugin: PluginDir): { contra
     const foreign = hostImports(join(plugin.dir, "web"))
     if (foreign.length) throw new EmitError(`web/ imports the host — a web half depends on its generated file, the document it is handed and the browser:\n${foreign.map(f => `  ${f}`).join("\n")}`)
   }
-  return { contract, files }
+  return { contract, manifest, files }
 }
 
 /** The imports of a web half that name a LeCodes package (`lecodes-sdk`, `lecodes-web-shared`, …), as
@@ -121,8 +123,26 @@ export const kotlinPackage = (android: string): { dir: string, name: string } =>
   return { dir, name: relative(root, dir).split(/[\\/]/).join(".") }
 }
 
+/** The SDK package's path the repo names for its Package.swift: `lecodes.iosSdkPath` of the repo's
+ *  package.json (the first-party repo, a submodule of core, says `../apple/lecodes`); else the default. */
+export const repoSdkPath = (root: string): string => {
+  const file = join(root, "package.json")
+  if (!existsSync(file)) return DEFAULT_SDK_PATH
+  try {
+    const pkg = JSON.parse(readFileSync(file, "utf8")) as { lecodes?: { iosSdkPath?: unknown } }
+    const path = pkg.lecodes?.iosSdkPath
+    if (path !== undefined && typeof path !== "string") throw new PackageError(`package.json lecodes.iosSdkPath: a path, as a string`)
+    return path ?? DEFAULT_SDK_PATH
+  } catch (e) {
+    if (e instanceof PackageError) throw e
+    throw new PackageError(`package.json does not parse: ${e instanceof Error ? e.message : String(e)}`)
+  }
+}
+
 export type GenReport = {
   plugins: { id: string, contract: Contract, written: string[], stale: string[], fresh: string[] }[]
+  /** The repo's own files (its Package.swift), when the path is a repo of plugins. */
+  repo: { written: string[], stale: string[], fresh: string[] }
   /** Contracts that did not read or emit, as printable text. */
   failures: string[]
 }
@@ -134,21 +154,24 @@ export const generate = (path: string, opts: { check?: boolean } = {}): GenRepor
   if (plugins.length === 0) throw new CliError(`No plugin under ${resolve(path)}: a plugin is a directory with a ${CONTRACT_FILE} (one, or plugins/<id>/ of a repo).`)
   const ts = loadTypescript(plugins[0]!.dir)
   const root = resolve(path)
-  const report: GenReport = { plugins: [], failures: [] }
+  const report: GenReport = { plugins: [], repo: { written: [], stale: [], fresh: [] }, failures: [] }
+  const place = (f: Generated, entry: { written: string[], stale: string[], fresh: string[] }): void => {
+    const name = shown(root, f.file) || basename(f.file)
+    const current = existsSync(f.file) ? readFileSync(f.file, "utf8") : null
+    if (current === f.text) { entry.fresh.push(name); return }
+    if (opts.check) { entry.stale.push(name); return }
+    mkdirSync(join(f.file, ".."), { recursive: true })
+    writeFileSync(f.file, f.text)
+    entry.written.push(name)
+  }
+  const manifests: { id: string, manifest: PluginManifest }[] = []
 
   for (const plugin of plugins) {
     try {
-      const { contract, files } = generatePlugin(ts, plugin)
+      const { contract, manifest, files } = generatePlugin(ts, plugin)
+      if (manifest) manifests.push({ id: plugin.id, manifest })
       const entry = { id: plugin.id, contract, written: [] as string[], stale: [] as string[], fresh: [] as string[] }
-      for (const f of files) {
-        const name = shown(root, f.file) || basename(f.file)
-        const current = existsSync(f.file) ? readFileSync(f.file, "utf8") : null
-        if (current === f.text) { entry.fresh.push(name); continue }
-        if (opts.check) { entry.stale.push(name); continue }
-        mkdirSync(join(f.file, ".."), { recursive: true })
-        writeFileSync(f.file, f.text)
-        entry.written.push(name)
-      }
+      for (const f of files) place(f, entry)
       report.plugins.push(entry)
     } catch (e) {
       if (e instanceof ContractError) report.failures.push(e.problems.map(p => `${shown(root, e.file) || e.file}:${p.line}: ${p.message}`).join("\n"))
@@ -157,5 +180,17 @@ export const generate = (path: string, opts: { check?: boolean } = {}): GenRepor
       else throw e
     }
   }
+
+  // A repo of plugins (not one plugin): its Package.swift, from every manifest that read. Written
+  // only when every contract made it — a repo with a broken plugin keeps the package it has.
+  const isRepo = !existsSync(join(root, CONTRACT_FILE))
+  if (isRepo && report.failures.length === 0 && manifests.some(m => m.manifest.ios)) {
+    try {
+      place({ file: join(root, PACKAGE_FILE), text: emitPackageSwift(manifests, repoSdkPath(root)) }, report.repo)
+    } catch (e) {
+      if (e instanceof PackageError) report.failures.push(`${PACKAGE_FILE}: ${e.message}`)
+      else throw e
+    }
+  }
   return report
 }