diff --git a/packages/debug/ember-data-logo-dark.svg b/packages/debug/ember-data-logo-dark.svg new file mode 100644 index 00000000000..737a4aa4321 --- /dev/null +++ b/packages/debug/ember-data-logo-dark.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/debug/ember-data-logo-light.svg b/packages/debug/ember-data-logo-light.svg new file mode 100644 index 00000000000..58ac3d4e544 --- /dev/null +++ b/packages/debug/ember-data-logo-light.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/graph/ember-data-logo-dark.svg b/packages/graph/ember-data-logo-dark.svg new file mode 100644 index 00000000000..737a4aa4321 --- /dev/null +++ b/packages/graph/ember-data-logo-dark.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/graph/ember-data-logo-light.svg b/packages/graph/ember-data-logo-light.svg new file mode 100644 index 00000000000..58ac3d4e544 --- /dev/null +++ b/packages/graph/ember-data-logo-light.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/model/ember-data-logo-dark.svg b/packages/model/ember-data-logo-dark.svg new file mode 100644 index 00000000000..737a4aa4321 --- /dev/null +++ b/packages/model/ember-data-logo-dark.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/model/ember-data-logo-light.svg b/packages/model/ember-data-logo-light.svg new file mode 100644 index 00000000000..58ac3d4e544 --- /dev/null +++ b/packages/model/ember-data-logo-light.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/private-build-infra/ember-data-logo-dark.svg b/packages/private-build-infra/ember-data-logo-dark.svg new file mode 100644 index 00000000000..737a4aa4321 --- /dev/null +++ b/packages/private-build-infra/ember-data-logo-dark.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/private-build-infra/ember-data-logo-light.svg b/packages/private-build-infra/ember-data-logo-light.svg new file mode 100644 index 00000000000..58ac3d4e544 --- /dev/null +++ b/packages/private-build-infra/ember-data-logo-light.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/tracking/ember-data-logo-dark.svg b/packages/tracking/ember-data-logo-dark.svg new file mode 100644 index 00000000000..737a4aa4321 --- /dev/null +++ b/packages/tracking/ember-data-logo-dark.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/packages/tracking/ember-data-logo-light.svg b/packages/tracking/ember-data-logo-light.svg new file mode 100644 index 00000000000..58ac3d4e544 --- /dev/null +++ b/packages/tracking/ember-data-logo-light.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/release/core/publish/index.ts b/release/core/publish/index.ts index 38590a605cd..d98917f30a3 100644 --- a/release/core/publish/index.ts +++ b/release/core/publish/index.ts @@ -4,6 +4,7 @@ import { GIT_TAG, getAllPackagesForGitTag, getGitState } from '../../utils/git'; import { printHelpDocs } from '../../help/docs'; import { bumpAllPackages, restorePackagesForDryRun } from './steps/bump-versions'; import { generatePackageTarballs } from './steps/generate-tarballs'; +import { generateMirrorTarballs } from './steps/generate-mirror-tarballs'; import { printStrategy } from './steps/print-strategy'; import { AppliedStrategy, applyStrategy } from './steps/generate-strategy'; import { confirmStrategy } from './steps/confirm-strategy'; @@ -13,6 +14,7 @@ import { CHANNEL, SEMVER_VERSION } from '../../utils/channel'; import { confirmCommitChangelogs } from '../release-notes/steps/confirm-changelogs'; import { updateChangelogs } from '../release-notes/steps/update-changelogs'; import { getChanges } from '../release-notes/steps/get-changes'; +import { generateTypesTarballs } from './steps/generate-types-tarballs'; export async function executePublish(args: string[]) { // get user supplied config @@ -68,8 +70,13 @@ export async function executePublish(args: string[]) { // Generate Tarballs in tmp/tarballs/ // Having applied the types publishing strategy "just in time" // ======================== - if (config.full.get('pack')) await generatePackageTarballs(config.full, packages, applied.public_pks); - else console.log(`Skipped Pack`); + if (config.full.get('pack')) { + await generatePackageTarballs(config.full, packages, applied.public_pks); + await generateMirrorTarballs(config.full, packages, applied.public_pks); + await generateTypesTarballs(config.full, packages, applied.public_pks); + } else { + console.log(`Skipped Pack`); + } // Publish to NPM registry // ======================== diff --git a/release/core/publish/steps/generate-mirror-tarballs.ts b/release/core/publish/steps/generate-mirror-tarballs.ts new file mode 100644 index 00000000000..4b6d96c0c1a --- /dev/null +++ b/release/core/publish/steps/generate-mirror-tarballs.ts @@ -0,0 +1,102 @@ +import { PROJECT_ROOT, TARBALL_DIR, toTarballName } from './generate-tarballs'; + +import { Glob } from 'bun'; +import { exec } from '../../../utils/cmd'; +import path from 'path'; +import fs from 'fs'; +import { APPLIED_STRATEGY, Package } from '../../../utils/package'; + +export async function generateMirrorTarballs( + config: Map, + packages: Map, + strategy: Map +) { + const tarballDir = path.join(TARBALL_DIR, packages.get('root')!.pkgData.version); + const tmpDir = path.join(PROJECT_ROOT, 'tmp/unpacked', packages.get('root')!.pkgData.version); + fs.mkdirSync(tmpDir, { recursive: true }); + + // for each public package + // if the package should be mirrored + // generate a tarball + // + // to do this we need to: + // - unpack the main tarball for the package + // - replace any references to the original package names with the mirrored package names in every file + // - pack a new tarball into the tarballs directory + // - add the tarball path to the package object + const toReplace = new Map(); + const cautionReplace = new Map(); + for (const [, strat] of strategy) { + if (strat.mirrorPublish) { + if (!strat.name.startsWith('@')) { + cautionReplace.set(strat.name, strat.mirrorPublishTo); + } else { + toReplace.set(strat.name, strat.mirrorPublishTo); + } + } + } + + for (const [, strat] of strategy) { + if (strat.mirrorPublish) { + const pkg = packages.get(strat.name)!; + const mirrorTarballPath = path.join( + tarballDir, + `${toTarballName(strat.mirrorPublishTo)}-${pkg.pkgData.version}.tgz` + ); + + // unpack the main tarball for the package + const mainTarballPath = pkg.tarballPath; + const unpackedDir = path.join(tmpDir, pkg.pkgData.name); + const realUnpackedDir = path.join(unpackedDir, 'package'); + + fs.mkdirSync(unpackedDir, { recursive: true }); + await exec(`tar -xf ${mainTarballPath} -C ${unpackedDir}`); + + // replace any references to the original package names with the mirrored package names in every file + // to do this we scan every file in the unpacked directory and do a string replace + const glob = new Glob('**/*'); + + for await (const filePath of glob.scan(realUnpackedDir)) { + const fullPath = path.join(realUnpackedDir, filePath); + const file = Bun.file(fullPath); + const fileData = await file.text(); + + let newContents = fileData; + for (const [from, to] of toReplace) { + newContents = newContents.replace(new RegExp(from, 'g'), to); + } + for (const [from, to] of cautionReplace) { + newContents = newContents.replace(new RegExp(`'${from}`, 'g'), `'${to}`); + newContents = newContents.replace(new RegExp(`"${from}`, 'g'), `"${to}`); + } + + newContents = newContents.replace(new RegExp(`'@ember-data/'`, 'g'), `'@ember-data-mirror/'`); + newContents = newContents.replace(new RegExp(`"@ember-data/"`, 'g'), `"@ember-data-mirror/"`); + + await Bun.write(fullPath, newContents); + } + + // fix the volta extends field in package.json + const packageJsonPath = path.join(realUnpackedDir, 'package.json'); + const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')); + if (packageJson.volta && packageJson.volta.extends) { + if (packageJson.name.includes('/')) { + packageJson.volta.extends = '../../../../../../package.json'; + } else { + packageJson.volta.extends = '../../../../../package.json'; + } + fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2)); + } + + // pack the new package and put it in the tarballs directory + const result = await exec({ + cwd: realUnpackedDir, + cmd: `npm pack --pack-destination=${tarballDir}`, + condense: false, + }); + console.log(result); + + pkg.mirrorTarballPath = mirrorTarballPath; + } + } +} diff --git a/release/core/publish/steps/generate-strategy.ts b/release/core/publish/steps/generate-strategy.ts index 70c1044a2c1..fdec96295d8 100644 --- a/release/core/publish/steps/generate-strategy.ts +++ b/release/core/publish/steps/generate-strategy.ts @@ -26,6 +26,34 @@ function sortByName(map: Map) { }); } +function getMirrorPackageName(name: string) { + if (name === 'root') { + return 'N/A'; + } + if (name.startsWith('@ember-data/')) { + return name.replace('@ember-data/', '@ember-data-mirror/'); + } else if (name.startsWith('@warp-drive/')) { + return name.replace('@warp-drive/', '@warp-drive-mirror/'); + } else if (name.startsWith('ember-data')) { + return name.replace('ember-data', 'ember-data-mirror'); + } + throw new Error(`Could not determine mirror package name for ${name}`); +} + +function getTypesPackageName(name: string) { + if (name === 'root') { + return 'N/A'; + } + if (name.startsWith('@ember-data/')) { + return name.replace('@ember-data/', '@ember-data-types/'); + } else if (name.startsWith('@warp-drive/')) { + return name.replace('@warp-drive/', '@warp-drive-types/'); + } else if (name.startsWith('ember-data')) { + return name.replace('ember-data', 'ember-data-types'); + } + throw new Error(`Could not determine types package name for ${name}`); +} + function getPkgDir(pkgFilePath: string) { const relative = path.relative(PROJECT_ROOT, pkgFilePath); const parts = relative.split('/'); @@ -73,6 +101,12 @@ export async function applyStrategy( applied_strategy.pkgDir = getPkgDir(pkg.filePath); applied_strategy.fromVersion = fromPkg ? fromPkg.pkgData.version : pkg.pkgData.version; applied_strategy.new = !fromPkg; + applied_strategy.mirrorPublish = + !applied_strategy.private && (rule.mirrorPublish ?? strategy.defaults.mirrorPublish ?? false); + applied_strategy.typesPublish = + !applied_strategy.private && (rule.typesPublish ?? strategy.defaults.typesPublish ?? false); + applied_strategy.mirrorPublishTo = applied_strategy.mirrorPublish ? getMirrorPackageName(name) : 'N/A'; + applied_strategy.typesPublishTo = applied_strategy.typesPublish ? getTypesPackageName(name) : 'N/A'; if (isDownversion) { // during a downversion, we do not allow publishing a package whose current strategy is diff --git a/release/core/publish/steps/generate-tarballs.ts b/release/core/publish/steps/generate-tarballs.ts index 65d63f6331c..905a9fd0e3b 100644 --- a/release/core/publish/steps/generate-tarballs.ts +++ b/release/core/publish/steps/generate-tarballs.ts @@ -5,10 +5,10 @@ import path from 'path'; import fs from 'fs'; import { Glob } from 'bun'; -const PROJECT_ROOT = process.cwd(); -const TARBALL_DIR = path.join(PROJECT_ROOT, 'tmp/tarballs'); +export const PROJECT_ROOT = process.cwd(); +export const TARBALL_DIR = path.join(PROJECT_ROOT, 'tmp/tarballs'); -function toTarballName(name: string) { +export function toTarballName(name: string) { return name.replace('@', '').replace('/', '-'); } @@ -61,7 +61,8 @@ export async function generatePackageTarballs( const pkgDir = path.join(PROJECT_ROOT, path.dirname(pkg.filePath)); const tarballPath = path.join(tarballDir, `${toTarballName(pkg.pkgData.name)}-${pkg.pkgData.version}.tgz`); pkg.tarballPath = tarballPath; - await exec({ cwd: pkgDir, cmd: `npm pack --pack-destination=${tarballDir}`, condense: true }); + const result = await exec({ cwd: pkgDir, cmd: `npm pack --pack-destination=${tarballDir}`, condense: false }); + console.log(result); } catch (e) { console.log(`🔴 ${chalk.redBright('failed to generate tarball for')} ${chalk.yellow(pkg.pkgData.name)}`); throw e; @@ -82,27 +83,27 @@ export async function generatePackageTarballs( async function fixVersionsInPackageJson(pkg: Package) { if (pkg.pkgData.dependencies) { Object.keys(pkg.pkgData.dependencies).forEach((dep) => { - const version = pkg.pkgData.dependencies[dep]; + const version = pkg.pkgData.dependencies![dep]; if (version.startsWith('workspace:')) { - pkg.pkgData.dependencies[dep] = version.replace('workspace:', ''); + pkg.pkgData.dependencies![dep] = version.replace('workspace:', ''); } }); } if (pkg.pkgData.devDependencies) { Object.keys(pkg.pkgData.devDependencies).forEach((dep) => { - const version = pkg.pkgData.devDependencies[dep]; + const version = pkg.pkgData.devDependencies![dep]; if (version.startsWith('workspace:')) { - pkg.pkgData.devDependencies[dep] = version.replace('workspace:', ''); + pkg.pkgData.devDependencies![dep] = version.replace('workspace:', ''); } }); } if (pkg.pkgData.peerDependencies) { Object.keys(pkg.pkgData.peerDependencies).forEach((dep) => { - const version = pkg.pkgData.peerDependencies[dep]; + const version = pkg.pkgData.peerDependencies![dep]; if (version.startsWith('workspace:')) { - pkg.pkgData.peerDependencies[dep] = version.replace('workspace:', ''); + pkg.pkgData.peerDependencies![dep] = version.replace('workspace:', ''); } }); } @@ -222,7 +223,7 @@ async function convertFileToModule(fileData: string, relativePath: string, pkgNa } // fix re-exports - else if (line.startsWith('export {')) { + else if (line.startsWith('export {') || line.startsWith('export type {')) { if (!line.includes('}')) { throw new Error(`Unhandled Re-export in ${relativePath}`); } @@ -411,7 +412,7 @@ async function restoreTypesStrategyChanges(pkg: Package, _strategy: APPLIED_STRA process.stdout.write( `\t\t♻️ ` + chalk.grey( - `Successfully Restored Assets Modified for Types Strategy During Publish in ${chalk.cyan(pkg.pkgData.name)}` + `Successfully Restored Assets Modified for Types Strategy During Publish in ${chalk.cyan(pkg.pkgData.name)}\n` ) ); } diff --git a/release/core/publish/steps/generate-types-tarballs.ts b/release/core/publish/steps/generate-types-tarballs.ts new file mode 100644 index 00000000000..357b2dbcb08 --- /dev/null +++ b/release/core/publish/steps/generate-types-tarballs.ts @@ -0,0 +1,101 @@ +import { PROJECT_ROOT, TARBALL_DIR, toTarballName } from './generate-tarballs'; + +import { exec } from '../../../utils/cmd'; +import path from 'path'; +import fs from 'fs'; +import { APPLIED_STRATEGY, Package } from '../../../utils/package'; + +const INVALID_FILES = new Set([ + 'src', + 'dist', + 'addon', + 'blueprints', + 'dist/docs', + 'addon-test-support', + 'app', + 'index.js', + 'addon-main.js', + 'addon-main.cjs', +]); + +export async function generateTypesTarballs( + config: Map, + packages: Map, + strategy: Map +) { + const tarballDir = path.join(TARBALL_DIR, packages.get('root')!.pkgData.version); + const tmpDir = path.join(PROJECT_ROOT, 'tmp/types', packages.get('root')!.pkgData.version); + fs.mkdirSync(tmpDir, { recursive: true }); + + // for each public package + // if that package has types + // generate a types tarball + // + // to do this we + // copy the types directory to a temporary directory + // create a new package.json + + for (const [, strat] of strategy) { + if (!strat.typesPublish || strat.private || strat.types === 'private') { + continue; + } + + if (strat.types === 'alpha') { + const tmpTypesDir = path.join(tmpDir, strat.typesPublishTo); + fs.mkdirSync(tmpTypesDir, { recursive: true }); + + // create a new package.json + const pkg = packages.get(strat.name)!; + const pkgData = pkg.pkgData; + const newPkgData = { + name: strat.typesPublishTo, + version: pkgData.version, + files: pkgData.files?.filter((f) => !INVALID_FILES.has(f)) ?? [], + private: false, + description: `Type Declarations for ${pkgData.name}`, + author: pkgData.author, + license: pkgData.license, + repository: pkgData.repository, + // try without any peers first + // peerDependencies: pkgData.peerDependencies, + // peerDependenciesMeta: pkgData.peerDependenciesMeta, + }; + const newPkgJson = path.join(tmpTypesDir, 'package.json'); + fs.writeFileSync(newPkgJson, JSON.stringify(newPkgData, null, 2)); + + // // copy the types directory + // const typesDir = path.join(path.dirname(pkg.filePath), 'unstable-preview-types'); + // if (!fs.existsSync(typesDir)) { + // throw new Error(`Types directory does not exist: ${typesDir}`); + // } + // const typesDest = path.join(tmpTypesDir, 'unstable-preview-types'); + // fs.mkdirSync(typesDest, { recursive: true }); + // await exec(`cp -r ${typesDir}/* ${typesDest}`); + + // copy files that are needed + const files = pkgData.files ?? []; + for (const file of files) { + const src = path.join(path.dirname(pkg.filePath), file); + const dest = path.join(tmpTypesDir, file); + fs.mkdirSync(path.dirname(dest), { recursive: true }); + await exec(`cp -r ${src} ${dest}`); + } + + // create the tarball + const tarballName = toTarballName(strat.typesPublishTo); + const tarballPath = path.join(tarballDir, `${tarballName}-${pkg.pkgData.version}.tgz`); + // pack the new package and put it in the tarballs directory + const result = await exec({ + cwd: tmpTypesDir, + cmd: `npm pack --pack-destination=${tarballDir}`, + condense: false, + }); + console.log(result); + + // update the package with the tarball path + pkg.typesTarballPath = tarballPath; + } else { + throw new Error(`Oops! Time to upgrade tis script to handled types strategy: ${strat.types}`); + } + } +} diff --git a/release/core/publish/steps/print-strategy.ts b/release/core/publish/steps/print-strategy.ts index 6e7263554e8..d6bb126c84c 100644 --- a/release/core/publish/steps/print-strategy.ts +++ b/release/core/publish/steps/print-strategy.ts @@ -11,10 +11,20 @@ export const COLORS_BY_STRATEGY: Record, applied: AppliedStrategy) { const tableRows = [ - [' ', 'Name', 'From Version', 'To Version', 'Stage', 'Types', 'NPM Dist Tag', 'Status', 'Location'], + [ + ' ', + 'Name', + 'Mirror', + 'Types', + 'From Version', + 'To Version', + 'Stage', + 'Types', + 'NPM Dist Tag', + 'Status', + 'Location', + ], ]; applied.public_pks.forEach((applied, name) => { tableRows.push([ applied.new ? chalk.magentaBright('New!') : '', colorName(name), + colorName(applied.mirrorPublishTo), + colorName(applied.typesPublishTo), chalk.grey(applied.fromVersion), chalk[COLORS_BY_STRATEGY[applied.stage]](applied.toVersion), chalk[COLORS_BY_STRATEGY[applied.stage]](applied.stage), @@ -74,6 +98,8 @@ export async function printStrategy(config: Map, reprompt?: boolean) { diff --git a/release/strategy.json b/release/strategy.json index aeec7e3524a..681d7fbd3e2 100644 --- a/release/strategy.json +++ b/release/strategy.json @@ -25,28 +25,38 @@ }, "defaults": { "stage": "stable", - "types": "alpha" + "types": "alpha", + "mirrorPublish": true, + "typesPublish": true }, "rules": { "@ember-data/debug": { "stage": "stable", - "types": "private" + "types": "private", + "typesPublish": false }, "@ember-data/private-build-infra": { "stage": "stable", - "types": "private" + "types": "private", + "typesPublish": false }, "@warp-drive/holodeck": { "stage": "alpha", - "types": "private" + "types": "private", + "typesPublish": false, + "mirrorPublish": false }, "@warp-drive/diagnostic": { "stage": "alpha", - "types": "private" + "types": "private", + "typesPublish": false, + "mirrorPublish": false }, "eslint-plugin-ember-data": { "stage": "alpha", - "types": "private" + "types": "private", + "typesPublish": false, + "mirrorPublish": false }, "@warp-drive/core-types": { "stage": "alpha", @@ -54,15 +64,21 @@ }, "@warp-drive/ember": { "stage": "alpha", - "types": "alpha" + "types": "alpha", + "typesPublish": false, + "mirrorPublish": false }, "@warp-drive/schema": { "stage": "alpha", - "types": "private" + "types": "private", + "typesPublish": false, + "mirrorPublish": false }, "@warp-drive/schema-record": { "stage": "alpha", - "types": "private" + "types": "private", + "typesPublish": false, + "mirrorPublish": false } } } diff --git a/release/utils/cmd.ts b/release/utils/cmd.ts index d4621b808f1..106de17d381 100644 --- a/release/utils/cmd.ts +++ b/release/utils/cmd.ts @@ -138,7 +138,9 @@ export async function exec(cmd: string[] | string | CMD, dryRun: boolean = false if (dryRun) { console.log(`\t` + chalk.grey(`Would Run: ${Array.isArray(mainCommand) ? mainCommand.join(' ') : mainCommand}`)); } else if (!isCmdWithConfig || (!cmd.condense && !cmd.silent)) { - console.log(`\t` + chalk.grey(`Running: ${args.join(' ')}\t...`)); + console.log( + `\t` + chalk.grey(`Running: ${args.join(' ')} in ${chalk.green(path.relative(process.cwd(), cwd))}\t...`) + ); } if (!dryRun) { diff --git a/release/utils/package.ts b/release/utils/package.ts index ab77142d5c9..9a0b1387575 100644 --- a/release/utils/package.ts +++ b/release/utils/package.ts @@ -7,12 +7,16 @@ export class Package { declare file: JSONFile; declare pkgData: PACKAGEJSON; declare tarballPath: string; + declare mirrorTarballPath: string; + declare typesTarballPath: string; constructor(filePath: string, file: JSONFile, pkgData: PACKAGEJSON) { this.filePath = filePath; this.file = file; this.pkgData = pkgData; this.tarballPath = ''; + this.mirrorTarballPath = ''; + this.typesTarballPath = ''; } async refresh() { @@ -60,6 +64,13 @@ export type PACKAGEJSON = { type?: 'addon'; version?: 1 | 2; }; + author?: string; + license?: string; + repository?: { + type: string; + url: string; + directory?: string; + }; }; export type APPLIED_STRATEGY = { @@ -67,6 +78,10 @@ export type APPLIED_STRATEGY = { private: boolean; stage: STRATEGY_TYPE; types: TYPE_STRATEGY; + mirrorPublish: boolean; + mirrorPublishTo: string; + typesPublish: boolean; + typesPublishTo: string; fromVersion: SEMVER_VERSION; toVersion: SEMVER_VERSION; distTag: NPM_DIST_TAG; @@ -90,12 +105,16 @@ export interface STRATEGY { defaults: { stage: STRATEGY_TYPE; types: TYPE_STRATEGY; + mirrorPublish?: boolean; + typesPublish?: boolean; }; rules: Record< string, { stage: STRATEGY_TYPE; types: TYPE_STRATEGY; + mirrorPublish?: boolean; + typesPublish?: boolean; } >; }