@sanity/plugin-kit 0.0.1-studio-v3.1

package/src/sanity/manifest.ts

@@ -0,0 +1,340 @@
+import fs from 'fs'
+import path from 'path'
+import util from 'util'
+import pkg from '../../package.json'
+import {buildExtensions} from '../configs/buildExtensions'
+import {hasSourceFile, hasCompiledFile, readJsonFile, fileExists} from '../util/files'
+import {errorToUndefined} from '../util/errorToUndefined'
+
+const stat = util.promisify(fs.stat)
+const readFile = util.promisify(fs.readFile)
+
+const allowedPartProps = ['name', 'implements', 'path', 'description']
+const disallowedPluginProps = ['api', 'project', 'plugins', 'env']
+
+export interface SanityV2Manifest {
+  root?: boolean
+  name: string
+  paths: ManifestPaths
+  parts?: {
+    path: string
+  }[]
+}
+
+export interface ManifestPaths {
+  basePath: string
+  compiled?: string
+  source?: string
+}
+
+export interface ManifestOptions {
+  isPlugin?: boolean
+  validate?: boolean
+  pluginName?: string
+  basePath: string
+  verifySourceParts?: boolean
+  verifyCompiledParts?: boolean
+  paths?: ManifestPaths
+  flags?: Record<string, any>
+}
+
+export async function getPaths(options: ManifestOptions) {
+  const {basePath} = options
+  const manifest = await readManifest(options)
+  if (!manifest.paths) {
+    return null
+  }
+
+  return absolutifyPaths(manifest.paths, basePath)
+}
+
+function absolutifyPaths(paths: ManifestPaths | undefined, basePath: string) {
+  const getPath = (relative?: string) =>
+    relative ? path.resolve(path.join(basePath, relative)) : undefined
+  return paths
+    ? {
+        basePath,
+        compiled: getPath(paths.compiled),
+        source: getPath(paths.source),
+      }
+    : {basePath}
+}
+
+export async function readManifest(options: ManifestOptions) {
+  const {basePath, validate = true} = options
+  const manifestPath = path.normalize(path.join(basePath, 'sanity.json'))
+
+  let content
+  try {
+    content = await readFile(manifestPath, 'utf8')
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        `No sanity.json found. sanity.json is required for plugins to function. Use \`${pkg.binname} init\` for a new plugin, or create an empty \`sanity.json\` with an empty object (\`{}\`) for existing ones.`
+      )
+    }
+
+    throw new Error(`Failed to read "${manifestPath}": ${err.message}`)
+  }
+
+  let parsed
+  try {
+    parsed = JSON.parse(content)
+  } catch (err: any) {
+    throw new Error(`Error parsing "${manifestPath}": ${err.message}`)
+  }
+
+  if (validate) {
+    await validateManifest(parsed, options)
+  }
+
+  return parsed
+}
+
+export async function validateManifest(manifest: SanityV2Manifest, opts: ManifestOptions) {
+  const options = {isPlugin: true, ...opts}
+
+  if (!isObject(manifest)) {
+    throw new Error(`Invalid sanity.json: Root must be an object`)
+  }
+
+  if (options.isPlugin) {
+    await validatePluginManifest(manifest, options)
+  } else {
+    await validateProjectManifest(manifest)
+  }
+
+  if ('root' in manifest && typeof manifest.root !== 'boolean') {
+    throw new Error(`Invalid sanity.json: "root" property must be a boolean if declared`)
+  }
+
+  await validateParts(manifest, {
+    ...options,
+    paths: absolutifyPaths(manifest.paths, options.basePath),
+  })
+}
+
+function validateProjectManifest(manifest: SanityV2Manifest) {
+  if ('paths' in manifest) {
+    throw new Error(`Invalid sanity.json: "paths" property has no meaning in a project manifest`)
+  }
+}
+
+export async function validatePluginManifest(
+  manifest: SanityV2Manifest,
+  options: {basePath: string}
+) {
+  const disallowed = Object.keys(manifest)
+    .filter((key) => disallowedPluginProps.includes(key))
+    .map((key) => `"${key}"`)
+
+  if (disallowed.length > 0) {
+    const plural = disallowed.length > 1 ? 's' : ''
+    const joined = disallowed.join(', ')
+    throw new Error(
+      `Invalid sanity.json: Key${plural} ${joined} ${
+        plural ? 'are' : 'is'
+      } not allowed in a plugin manifest`
+    )
+  }
+
+  if (manifest.root) {
+    throw new Error(`Invalid sanity.json: "root" cannot be truthy in a plugin manifest`)
+  }
+
+  await validatePaths(manifest, options)
+}
+
+export async function validatePaths(manifest: SanityV2Manifest, options: {basePath: string}) {
+  if (!('paths' in manifest)) {
+    return
+  }
+
+  if (!isObject(manifest.paths)) {
+    throw new Error(`Invalid sanity.json: "paths" must be an object if declared`)
+  }
+
+  if (typeof manifest.paths.compiled !== 'string') {
+    throw new Error(
+      `Invalid sanity.json: "paths" must have a (string) "compiled" property if declared`
+    )
+  }
+
+  if (typeof manifest.paths.source !== 'string') {
+    throw new Error(
+      `Invalid sanity.json: "paths" must have a (string) "source" property if declared`
+    )
+  }
+
+  const sourcePath = path.resolve(options.basePath, manifest.paths.source)
+  let srcStats
+  try {
+    srcStats = await stat(sourcePath)
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`sanity.json references "source" path which does not exist: "${sourcePath}"`)
+    }
+  }
+
+  if (!srcStats?.isDirectory()) {
+    throw new Error(
+      `sanity.json references "source" path which is not a directory: "${sourcePath}"`
+    )
+  }
+}
+
+async function validateParts(manifest: SanityV2Manifest, options: ManifestOptions) {
+  if (!('parts' in manifest)) {
+    return
+  }
+
+  if (!Array.isArray(manifest.parts)) {
+    throw new Error(`Invalid sanity.json: "parts" must be an array if declared`)
+  }
+
+  let i = 0
+  for (const part of manifest.parts) {
+    await validatePart(part, i, options)
+    i++
+  }
+}
+
+async function validatePart(part: Record<string, any>, index: number, options: ManifestOptions) {
+  if (!isObject(part)) {
+    throw new Error(`Invalid sanity.json: "parts[${index}]" must be an object`)
+  }
+
+  validateAllowedPartKeys(part, index)
+  validatePartStringValues(part, index)
+  validatePartNames(part, index, options)
+  await validatePartFiles(part, index, options)
+}
+
+async function validatePartFiles(
+  part: {path?: string} | undefined,
+  index: number,
+  options: ManifestOptions
+) {
+  const {verifyCompiledParts, verifySourceParts, paths} = options
+  if (!part?.path) {
+    return
+  }
+
+  const ext = path.extname(part.path)
+  if (paths?.source && ext && ext !== '.js' && buildExtensions.includes(ext)) {
+    throw new Error(
+      `Invalid sanity.json: Part path has extension which is not applicable after compiling. ${ext} becomes .js after compiling. Specify filename without extension (${path.basename(
+        part.path
+      )}) (parts[${index}])`
+    )
+  }
+
+  if (!verifySourceParts && !verifyCompiledParts) {
+    return
+  }
+
+  const [srcExists, libExists] = await Promise.all([
+    hasSourceFile(part.path, paths),
+    verifyCompiledParts && hasCompiledFile(part.path, paths),
+  ])
+
+  if (!srcExists) {
+    throw new Error(
+      `Invalid sanity.json: Part path references file that does not exist in source directory (${
+        paths?.source || paths?.basePath
+      }) (parts[${index}])`
+    )
+  }
+
+  if (verifyCompiledParts && !libExists) {
+    throw new Error(
+      `Invalid sanity.json: Part path references file ("${part.path}") that does not exist in compiled directory (${paths?.compiled}) (parts[${index}])`
+    )
+  }
+}
+
+function validatePartNames(
+  part: {name?: string; implements?: string} | undefined,
+  index: number,
+  options: ManifestOptions
+) {
+  const pluginName = options.pluginName ? options.pluginName.replace(/^sanity-plugin-/, '') : ''
+  if (!part?.name || !part?.name?.startsWith(`part:${pluginName}/`)) {
+    throw new Error(
+      `Invalid sanity.json: "name" must be prefixed with "part:${pluginName}/" - got "${part?.name}" (parts[${index}])`
+    )
+  }
+
+  if (!part?.implements?.startsWith('part:')) {
+    throw new Error(
+      `Invalid sanity.json: "implements" must be prefixed with "part:" - got "${part?.implements}" (parts[${index}])`
+    )
+  }
+}
+
+function validateAllowedPartKeys(part: Record<string, any>, index: number) {
+  const disallowed = Object.keys(part)
+    .filter((key) => !allowedPartProps.includes(key))
+    .map((key) => `"${key}"`)
+
+  if (disallowed.length > 0) {
+    const plural = disallowed.length > 1 ? 's' : ''
+    const joined = disallowed.join(', ')
+    throw new Error(
+      `Invalid sanity.json: Key${plural} ${joined} ${
+        plural ? 'are' : 'is'
+      } not allowed in a part declaration (parts[${index}])`
+    )
+  }
+}
+
+function validatePartStringValues(part: Record<string, any>, index: number) {
+  const nonStrings = Object.keys(part)
+    .filter((key) => typeof part[key] !== 'string')
+    .map((key) => `"${key}"`)
+
+  if (nonStrings.length > 0) {
+    const plural = nonStrings.length > 1 ? 's' : ''
+    const joined = nonStrings.join(', ')
+    throw new Error(
+      `Invalid sanity.json: Key${plural} ${joined} should be of type string (parts[${index}])`
+    )
+  }
+}
+
+function isObject(obj: any) {
+  return !Array.isArray(obj) && obj !== null && typeof obj === 'object'
+}
+
+export function getReferencesPartPaths(manifest: SanityV2Manifest, basePath: string) {
+  const {paths, parts = []} = manifest
+  const compiledPath = path.resolve(basePath, paths?.compiled || '')
+
+  return parts
+    .filter((part) => part.path)
+    .map((part) => part.path)
+    .map((partPath) => (path.extname(partPath) === '' ? `${partPath}.js` : partPath))
+    .map((partPath) =>
+      path.isAbsolute(partPath)
+        ? partPath // Not sure if this ever happens, but :shrugs:
+        : path.resolve(compiledPath, partPath)
+    )
+}
+
+export async function hasSanityJson(basePath: string) {
+  const file = await readJsonFile<{root?: boolean}>(path.join(basePath, 'sanity.json')).catch(
+    errorToUndefined
+  )
+  return {exists: Boolean(file), isRoot: Boolean(file && file.root)}
+}
+
+export async function findStudioV3Config(basePath: string) {
+  const jsFile = 'sanity.config.js'
+  const jsExists = await fileExists(path.join(basePath, jsFile))
+  if (jsExists) {
+    return {v3ConfigFile: jsFile}
+  }
+  const tsFile = 'sanity.config.ts'
+  const tsExists = await fileExists(path.join(basePath, tsFile))
+  return {v3ConfigFile: tsExists ? tsFile : undefined}
+}

package/src/sharedFlags.ts

@@ -0,0 +1,14 @@
+export default {
+  debug: {
+    default: false,
+    type: 'boolean',
+  },
+  silent: {
+    type: 'boolean',
+    default: false,
+  },
+  verbose: {
+    type: 'boolean',
+    default: false,
+  },
+} as const

package/src/util/command-parser.ts

@@ -0,0 +1,31 @@
+import childProcess from 'child_process'
+import npmRunPath from 'npm-run-path'
+import log from './log'
+
+interface Command {
+  command: string
+  args: string[]
+}
+
+export function parseCommand(commandString: string): Command {
+  const normalized = commandString.replace(/ +/g, ' ')
+  const commandAndArg = normalized.split(' ')
+  return {
+    command: commandAndArg[0],
+    args: commandAndArg.length > 1 ? commandAndArg.slice(1) : [],
+  }
+}
+
+export async function runCommand(commandString: string): Promise<{code: number}> {
+  log.info(`Running command: ${commandString}`)
+  const {command, args} = parseCommand(commandString)
+
+  let options: any = {stdio: 'inherit', env: npmRunPath.env()}
+
+  // ref: https://stackoverflow.com/questions/37459717/error-spawn-enoent-on-windows/37487465
+  options = process.platform === 'win32' ? {...options, shell: true} : options
+
+  return new Promise((resolve, reject) => {
+    childProcess.spawn(command, args, options).on('error', reject).on('close', resolve)
+  })
+}

package/src/util/errorToUndefined.ts

@@ -0,0 +1,7 @@
+export function errorToUndefined(err: any) {
+  if (err instanceof TypeError) {
+    throw err
+  }
+
+  return undefined
+}

package/src/util/files.ts

@@ -0,0 +1,249 @@
+import fs from 'fs'
+import path from 'path'
+import util from 'util'
+import pAny from 'p-any'
+import crypto from 'crypto'
+import {buildExtensions} from '../configs/buildExtensions'
+import {prompt} from './prompt'
+import {InitFlags} from '../actions/init'
+import log from './log'
+import json5 from 'json5'
+import {ManifestPaths} from '../sanity/manifest'
+
+export const stat = util.promisify(fs.stat)
+export const mkdir = util.promisify(fs.mkdir)
+export const readdir = util.promisify(fs.readdir)
+export const copyFile = util.promisify(fs.copyFile)
+export const readFile = util.promisify(fs.readFile)
+export const writeFile = util.promisify(fs.writeFile)
+
+export function hasSourceEquivalent(compiledFile: string, paths: ManifestPaths) {
+  if (!paths.source) {
+    return fileExists(
+      path.isAbsolute(compiledFile) ? compiledFile : path.resolve(paths.basePath, compiledFile)
+    )
+  }
+
+  // /plugin/lib/MyComponent.js => /plugin/src
+  const baseDir = path.dirname(compiledFile.replace(paths.compiled as string, paths.source))
+
+  // /plugin/lib/MyComponent.js => MyComponent
+  const baseName = path.basename(compiledFile, path.extname(compiledFile))
+
+  // MyComponent => /plugin/src/MyComponent
+  const pathStub = path.join(baseDir, baseName)
+
+  /*
+   * /plugin/src/MyComponent => [
+   *   /plugin/src/MyComponent.jsx,
+   *   /plugin/src/MyComponent.mjs,
+   *   ...
+   * ]
+   */
+  return buildCandidateExists(pathStub)
+}
+
+// Generally used for parts resolving
+export async function hasSourceFile(filePath: string, paths?: ManifestPaths) {
+  if (!paths?.source) {
+    return fileExists(
+      path.isAbsolute(filePath) ? filePath : path.resolve(paths?.basePath ?? '', filePath)
+    )
+  }
+
+  // filePath: components/SomeInput
+  // paths: {source: '/plugin/src'}
+  // MyComponent => /plugin/src/MyComponent
+  const pathStub = path.isAbsolute(filePath) ? filePath : path.resolve(paths.source, filePath)
+
+  if (await fileExists(pathStub)) {
+    return true
+  }
+
+  return buildCandidateExists(pathStub)
+}
+
+// Generally used for parts resolving
+export function hasCompiledFile(filePath: string, paths?: ManifestPaths) {
+  if (!paths?.compiled) {
+    return fileExists(
+      path.isAbsolute(filePath) ? filePath : path.resolve(paths?.basePath ?? '', filePath)
+    )
+  }
+
+  // filePath: components/SomeInput
+  // paths: {compiled: '/plugin/lib'}
+
+  // components/SomeInput => /plugin/lib/components/SomeInput
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(paths.compiled, filePath)
+
+  // /plugin/lib/components/SomeInput     => /plugin/lib/components/SomeInput.js
+  // /plugin/lib/components/SomeInput.js  => /plugin/lib/components/SomeInput.js
+  // /plugin/lib/components/SomeInput.css => /plugin/lib/components/SomeInput.css
+  const fileExt = path.extname(absPath)
+  const withExt = fileExt === '' ? `${absPath}.js` : absPath
+
+  return fileExists(withExt)
+}
+
+export function buildCandidateExists(pathStub: string) {
+  const candidates = buildExtensions.map((extCandidate) => `${pathStub}${extCandidate}`)
+
+  return pAny(candidates.map((candidate) => stat(candidate)))
+    .then(() => true)
+    .catch(() => false)
+}
+
+export function fileExists(filePath: string) {
+  return stat(filePath)
+    .then(() => true)
+    .catch(() => false)
+}
+
+export async function readJsonFile<T>(filePath: string) {
+  const content = await readFile(filePath, 'utf8')
+  return JSON.parse(content) as T
+}
+
+export function writeJsonFile(filePath: string, content: Record<string, unknown>) {
+  const data = JSON.stringify(content, null, 2)
+  return writeFile(filePath, data, {encoding: 'utf8'})
+}
+
+export async function writeFileWithOverwritePrompt(
+  filePath: string,
+  content: string,
+  options: {default?: any; force?: boolean} & fs.ObjectEncodingOptions
+) {
+  const {default: defaultVal, force = false, ...writeOptions} = options
+  const withinCwd = filePath.startsWith(process.cwd())
+  const printablePath = withinCwd ? path.relative(process.cwd(), filePath) : filePath
+
+  if (await fileEqualsData(filePath, content)) {
+    return false
+  }
+
+  if (
+    !force &&
+    (await fileExists(filePath)) &&
+    !(await prompt(`File "${printablePath}" already exists. Overwrite?`, {
+      type: 'confirm',
+      default: defaultVal,
+    }))
+  ) {
+    return false
+  }
+
+  await writeFile(filePath, content, writeOptions)
+  return true
+}
+
+export async function copyFileWithOverwritePrompt(from: string, to: string, flags: InitFlags) {
+  const withinCwd = to.startsWith(process.cwd())
+  const printablePath = withinCwd ? path.relative(process.cwd(), to) : to
+
+  if (await filesAreEqual(from, to)) {
+    return false
+  }
+
+  if (
+    !flags.force &&
+    (await fileExists(to)) &&
+    !(await prompt(`File "${printablePath}" already exists. Overwrite?`, {
+      type: 'confirm',
+      default: false,
+    }))
+  ) {
+    return false
+  }
+
+  await copyFile(from, to)
+  return true
+}
+
+export async function fileEqualsData(filePath: string, content: string) {
+  const contentHash = crypto.createHash('sha1').update(content).digest('hex')
+  const remoteHash = await getFileHash(filePath)
+  return contentHash === remoteHash
+}
+
+export async function filesAreEqual(file1: string, file2: string) {
+  const [hash1, hash2] = await Promise.all([getFileHash(file1, false), getFileHash(file2)])
+  return hash1 === hash2
+}
+
+export function getFileHash(filePath: string, allowMissing = true) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha1')
+    const stream = fs.createReadStream(filePath)
+    stream.on('error', (err) => {
+      if ((err as unknown as {code?: string}).code === 'ENOENT' && allowMissing) {
+        resolve(null)
+      } else {
+        reject(err)
+      }
+    })
+
+    stream.on('end', () => resolve(hash.digest('hex')))
+    stream.on('data', (chunk) => hash.update(chunk))
+  })
+}
+
+export async function ensureDir(dirPath: string) {
+  try {
+    await mkdir(dirPath)
+  } catch (err) {
+    if ((err as unknown as {code?: string}).code !== 'EEXIST') {
+      throw err
+    }
+  }
+}
+
+export async function isEmptyish(dirPath: string) {
+  const ignoredFiles = ['.git', '.gitignore', 'license', 'readme.md']
+  const allFiles = await readdir(dirPath).catch(() => [])
+  const files = allFiles.filter((file) => !ignoredFiles.includes(file.toLowerCase()))
+  return files.length === 0
+}
+
+export async function readFileContent({
+  filename,
+  basePath,
+}: {
+  filename: string
+  basePath: string
+}): Promise<string | undefined> {
+  const filepath = path.normalize(path.join(basePath, filename))
+  try {
+    return await readFile(filepath, 'utf8')
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      log.debug(`No ${filename} file found.`)
+      return undefined
+    }
+    throw new Error(`Failed to read "${filepath}": ${err.message}`)
+  }
+}
+
+export async function readJson5File<T>({
+  filename,
+  basePath,
+}: {
+  filename: string
+  basePath: string
+}): Promise<T | undefined> {
+  const content = await readFileContent({filename, basePath})
+  if (!content) {
+    return undefined
+  }
+
+  return parseJson5<T>(content, filename)
+}
+
+export function parseJson5<T>(content: string, errorKey: string): T {
+  try {
+    return json5.parse<T>(content)
+  } catch (err: any) {
+    throw new Error(`Error parsing "${errorKey}": ${err.message}`)
+  }
+}

package/src/util/log.ts

@@ -0,0 +1,44 @@
+// Note: This is _specifically_ meant for CLI usage,
+// I realize that "singletons" are bad.
+
+import chalk from 'chalk'
+
+let beQuiet = false
+let beVerbose = false
+
+function setVerbosity({verbose, silent}: {verbose: boolean; silent: boolean}) {
+  if (silent) {
+    beVerbose = false
+    beQuiet = true
+  } else if (verbose) {
+    beVerbose = true
+    beQuiet = false
+  }
+}
+
+export default {
+  setVerbosity: setVerbosity,
+
+  // Bypasses any checks, prints regardless (only use for things like `cli --version`)
+  msg: (msg: any, ...args: any[]) => !beQuiet && console.log(msg, ...args),
+
+  // Debug only printed on --verbose
+  debug: (msg: any, ...args: any[]) =>
+    !beQuiet && beVerbose && console.debug(`${chalk.bgBlack.white('[debug]')} ${msg}`, ...args),
+
+  // Success messages only printed if not --silent
+  success: (msg: any, ...args: any[]) =>
+    !beQuiet && console.info(`${chalk.bgBlack.greenBright('[success]')} ${msg}`, ...args),
+
+  // Info only printed if not --silent ("standard" level)
+  info: (msg: any, ...args: any[]) =>
+    !beQuiet && console.info(`${chalk.bgBlack.cyanBright('[info]')} ${msg}`, ...args),
+
+  // Warning only printed if not --silent
+  warn: (msg: any, ...args: any[]) =>
+    !beQuiet && console.warn(`${chalk.bgBlack.yellowBright('[warn]')} ${msg}`, ...args),
+
+  // Errors are always printed
+  error: (msg: any, ...args: any[]) =>
+    console.error(`${chalk.bgBlack.redBright('[error]')} ${msg}`, ...args),
+}