@stacksjs/defaults 0.75.41 → 0.75.42

package/ide/vscode/tests/env.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Env file support (src/env.ts, src/env-file.ts). Values are encrypted with
+ * `@stacksjs/env`'s own `encryptValue`, so the round trip is the real one.
+ */
+import { describe, expect, it } from 'bun:test'
+import { encryptValue, generateKeypair } from '../../../../core/env/src/crypto'
+import { createEnvSupport, projectDecryptor } from '../src/env'
+import { decryptEnvValue, envEntryAt, findPrivateKey, isEnvFile, missingKeys } from '../src/env-file'
+import { loadProjectEnv } from '../src/project'
+import { document, fakeVscode, flush, Position } from './fake-vscode'
+
+const ROOT = '/work/app'
+const { publicKey, privateKey } = generateKeypair()
+const other = generateKeypair()
+const SECRET = 's3cret value with spaces'
+const ENCRYPTED = encryptValue(SECRET, publicKey)
+
+describe('env files', () => {
+  it('knows env files from the private key file', () => {
+    expect(['.env', '.env.local', '.env.production', '.env.example'].every(name => isEnvFile(`${ROOT}/${name}`))).toBeTrue()
+    expect(isEnvFile(`${ROOT}/.env.keys`)).toBeFalse()
+    expect(isEnvFile(`${ROOT}/env.ts`)).toBeFalse()
+  })
+
+  it('finds the value on a line, quotes excluded', () => {
+    expect(envEntryAt('export API_KEY="abc"')).toEqual({ key: 'API_KEY', value: 'abc', start: 16, end: 19 })
+    expect(envEntryAt('PORT=3000 # dev')).toEqual({ key: 'PORT', value: '3000', start: 5, end: 9 })
+    expect(envEntryAt('# just a comment')).toBeUndefined()
+  })
+
+  it('lists the keys .env.example has and .env does not', () => {
+    expect(missingKeys('APP_NAME=\nAPP_KEY=\n# note\nDB_HOST=', 'APP_NAME=Stacks\nexport DB_HOST=x')).toEqual(['APP_KEY'])
+  })
+})
+
+describe('private keys', () => {
+  it('looks them up the way ./buddy env:get does: the file\'s key, then the plain one, .env.keys before the environment', () => {
+    const keys = 'DOTENV_PRIVATE_KEY=plain\nDOTENV_PRIVATE_KEY_PRODUCTION=prod'
+    expect(findPrivateKey(`${ROOT}/.env.production`, keys, {})).toEqual({ name: 'DOTENV_PRIVATE_KEY_PRODUCTION', key: 'prod', from: '.env.keys' })
+    expect(findPrivateKey(`${ROOT}/.env.staging`, keys, {})).toEqual({ name: 'DOTENV_PRIVATE_KEY', key: 'plain', from: '.env.keys' })
+    expect(findPrivateKey(`${ROOT}/.env.production`, undefined, { DOTENV_PRIVATE_KEY_PRODUCTION: 'ci' })).toEqual({ name: 'DOTENV_PRIVATE_KEY_PRODUCTION', key: 'ci', from: 'environment' })
+    expect(findPrivateKey(`${ROOT}/.env`, undefined, {})).toBeUndefined()
+  })
+
+  it('decrypts with @stacksjs/env, and says why when it cannot', () => {
+    expect(decryptEnvValue(`${ROOT}/.env`, ENCRYPTED, `DOTENV_PRIVATE_KEY=${privateKey}`, {})).toMatchObject({ ok: true, value: SECRET })
+    expect(decryptEnvValue(`${ROOT}/.env`, ENCRYPTED, undefined, {})).toEqual({ ok: false, reason: 'no-key', looked: ['DOTENV_PRIVATE_KEY'] })
+    expect(decryptEnvValue(`${ROOT}/.env`, ENCRYPTED, `DOTENV_PRIVATE_KEY=${other.privateKey}`, {})).toMatchObject({ ok: false, reason: 'failed' })
+  })
+
+  it('lets the preview read an encrypted APP_URL, and still skips one it cannot decrypt', () => {
+    const files: Record<string, string> = {
+      [`${ROOT}/.env`]: `APP_URL=${ENCRYPTED}\nPORT=${encryptValue('3100', other.publicKey)}`,
+      [`${ROOT}/.env.keys`]: `DOTENV_PRIVATE_KEY=${privateKey}`,
+    }
+    const host = { exists: (path: string) => path in files, read: (path: string) => files[path], exec: async () => '', environment: {} }
+    const env = loadProjectEnv(file => files[`${ROOT}/${file}`], ['.env'], projectDecryptor(host, ROOT))
+    expect(env).toEqual({ APP_URL: SECRET })
+  })
+})
+
+function setup(files: Record<string, string>, settings: Record<string, unknown> = {}) {
+  const host = {
+    exists: (path: string) => path in files,
+    read: (path: string) => files[path],
+    execs: [] as string[][],
+    async exec(file: string, args: string[], cwd: string) {
+      host.execs.push([file, ...args, `(in ${cwd})`])
+      return 'the value\n'
+    },
+    environment: {},
+  }
+  const fake = fakeVscode({ folders: [ROOT], settings })
+  const support = createEnvSupport(fake.api as any, host)
+  support.activate(fake.context)
+  return { ...fake, host }
+}
+
+describe('hover', () => {
+  const line = `API_KEY="${ENCRYPTED}"`
+  const files = { [`${ROOT}/buddy`]: '', [`${ROOT}/.env.keys`]: `DOTENV_PRIVATE_KEY=${privateKey}` }
+
+  it('shows an encrypted value decrypted, and names the key it used', () => {
+    const { hovers } = setup(files)
+    const hover = hovers[0].provideHover(document(`${ROOT}/.env`, line, 'dotenv'), new Position(0, 20))
+
+    expect(hover.contents.value).toContain(SECRET)
+    expect(hover.contents.value).toContain('`DOTENV_PRIVATE_KEY` from `.env.keys`')
+    expect(hover.range.start.character).toBe(9)
+  })
+
+  it('explains a value it has no key for', () => {
+    const { hovers } = setup({ [`${ROOT}/buddy`]: '' })
+    const hover = hovers[0].provideHover(document(`${ROOT}/.env`, line, 'dotenv'), new Position(0, 20))
+    expect(hover.contents.value).toContain('No private key')
+    expect(hover.contents.value).not.toContain(SECRET)
+  })
+
+  it('stays quiet on plaintext, on the key name, in other files and when turned off', () => {
+    expect(setup(files).hovers[0].provideHover(document(`${ROOT}/.env`, 'PORT=3000', 'dotenv'), new Position(0, 6))).toBeUndefined()
+    expect(setup(files).hovers[0].provideHover(document(`${ROOT}/.env`, line, 'dotenv'), new Position(0, 2))).toBeUndefined()
+    expect(setup(files).hovers[0].provideHover(document(`${ROOT}/app/x.ts`, line), new Position(0, 20))).toBeUndefined()
+    expect(setup(files, { 'env.decryptOnHover': false }).hovers[0].provideHover(document(`${ROOT}/.env`, line, 'dotenv'), new Position(0, 20))).toBeUndefined()
+  })
+})
+
+describe('missing keys', () => {
+  it('flags keys .env.example declares that .env does not set', async () => {
+    const { diagnostics, events } = setup({ [`${ROOT}/.env.example`]: 'APP_NAME=\nAPP_KEY=\n' })
+    events.opened.fire(document(`${ROOT}/.env`, 'APP_NAME=Stacks\n', 'dotenv') as any)
+    await flush()
+
+    const list = diagnostics.get(`file://${ROOT}/.env`)!
+    expect(list.map((diagnostic: any) => diagnostic.message)).toEqual(['APP_KEY is in .env.example but not set here.'])
+    expect(list[0].severity).toBe(2)
+  })
+
+  it('does not compare other env files, which legitimately differ', async () => {
+    const { diagnostics, events } = setup({ [`${ROOT}/.env.example`]: 'APP_KEY=\n' })
+    events.opened.fire(document(`${ROOT}/.env.production`, '', 'dotenv') as any)
+    await flush()
+    expect(diagnostics.get(`file://${ROOT}/.env.production`)).toBeUndefined()
+  })
+})
+
+describe('buddy env commands', () => {
+  const files = { [`${ROOT}/buddy`]: '', [`${ROOT}/.env`]: 'APP_NAME=Stacks\nAPI_KEY=x\n' }
+
+  it('sets a value through ./buddy env:set, without a shell, from a password box', async () => {
+    const fake = setup(files)
+    fake.answers.push('API_KEY', 'hunter2')
+    await fake.handlers.get('stacks.env.set')!()
+
+    expect(fake.host.execs).toEqual([[`${ROOT}/buddy`, 'env:set', 'API_KEY', 'hunter2', '--file', '.env', `(in ${ROOT})`]])
+    expect(fake.inputs[1].password).toBeTrue()
+  })
+
+  it('gets a value through ./buddy env:get and copies it only when asked', async () => {
+    const fake = setup(files)
+    fake.answers.push('API_KEY', 'Copy Value')
+    await fake.handlers.get('stacks.env.get')!()
+
+    expect(fake.host.execs[0]!.slice(1, 5)).toEqual(['env:get', 'API_KEY', '--file', '.env'])
+    expect(fake.messages[0]).not.toContain('the value')
+    expect(fake.clipboard).toEqual(['the value'])
+  })
+
+  it('asks before writing plaintext to disk', async () => {
+    const fake = setup(files)
+    fake.answers.push(undefined)
+    await fake.handlers.get('stacks.env.decrypt')!()
+    expect(fake.host.execs).toEqual([])
+    expect(fake.messages[0]).toContain('plaintext')
+
+    fake.answers.push('Continue', undefined)
+    await fake.handlers.get('stacks.env.decrypt')!()
+    expect(fake.host.execs[0]!.slice(1, 4)).toEqual(['env:decrypt', '--file', '.env'])
+  })
+
+  it('acts on the env file that is open', async () => {
+    const fake = setup({ ...files, [`${ROOT}/.env.production`]: 'APP_KEY=x\n' })
+    fake.api.window.activeTextEditor = { document: document(`${ROOT}/.env.production`, '', 'dotenv') }
+    await fake.handlers.get('stacks.env.encrypt')!()
+    expect(fake.host.execs[0]!.slice(1, 4)).toEqual(['env:encrypt', '--file', '.env.production'])
+  })
+})

package/ide/vscode/tests/extension.test.ts

@@ -216,6 +216,14 @@ describe('activation', () => {
     expect([...handlers.keys()].sort()).toEqual([COMMANDS.openPreview, COMMANDS.runBuddyCommand, COMMANDS.startDevServer].sort())
     expect(executed).toContainEqual({ command: 'setContext', args: ['stacks.isProject', true] })
   })
+
+  it('stays out of the way in a workspace that is not a Stacks project', () => {
+    // The extension also activates for .stx files anywhere, for its stx support.
+    const { handlers, executed, context } = setup({ noBuddy: true })
+    expect(executed).toContainEqual({ command: 'setContext', args: ['stacks.isProject', false] })
+    expect(handlers.size).toBe(3)
+    expect(context.subscriptions.some((item: any) => 'text' in item)).toBeFalse()
+  })
 })
 
 describe('Stacks: Open Preview', () => {

package/ide/vscode/tests/fake-vscode.ts

@@ -0,0 +1,228 @@
+/**
+ * Just enough of the `vscode` API for ./pickier.test.ts and ./env.test.ts:
+ * documents, diagnostics, code actions, hovers and the provider registries,
+ * recorded so tests can call the providers the way the editor would.
+ */
+
+type Listener<T> = (event: T) => unknown
+
+export function emitter<T>() {
+  const listeners = new Set<Listener<T>>()
+  return {
+    event: (listener: Listener<T>) => {
+      listeners.add(listener)
+      return { dispose: () => listeners.delete(listener) }
+    },
+    fire: (value: T) => {
+      for (const listener of [...listeners]) listener(value)
+    },
+  }
+}
+
+export class Position {
+  constructor(readonly line: number, readonly character: number) {}
+  translate(lines = 0, characters = 0) {
+    return new Position(this.line + lines, this.character + characters)
+  }
+}
+
+export class Range {
+  readonly start: Position
+  readonly end: Position
+  constructor(a: Position | number, b: Position | number, c?: number, d?: number) {
+    this.start = typeof a === 'number' ? new Position(a, b as number) : a
+    this.end = typeof a === 'number' ? new Position(c as number, d as number) : b as Position
+  }
+}
+
+export class CodeActionKind {
+  static readonly QuickFix = new CodeActionKind('quickfix')
+  static readonly SourceFixAll = new CodeActionKind('source.fixAll')
+  constructor(readonly value: string) {}
+  append(part: string) {
+    return new CodeActionKind(`${this.value}.${part}`)
+  }
+
+  contains(other: CodeActionKind) {
+    return other.value === this.value || other.value.startsWith(`${this.value}.`)
+  }
+}
+
+export class WorkspaceEdit {
+  readonly edits: Array<{ uri: unknown, range?: Range, position?: Position, text: string }> = []
+  replace(uri: unknown, range: Range, text: string) {
+    this.edits.push({ uri, range, text })
+  }
+
+  insert(uri: unknown, position: Position, text: string) {
+    this.edits.push({ uri, position, text })
+  }
+}
+
+export class MarkdownString {
+  value = ''
+  appendMarkdown(text: string) {
+    this.value += text
+    return this
+  }
+
+  appendCodeblock(code: string, language = '') {
+    this.value += `\n\`\`\`${language}\n${code}\n\`\`\`\n`
+    return this
+  }
+}
+
+export interface FakeDocument {
+  uri: { fsPath: string, scheme: string, toString: () => string }
+  languageId: string
+  version: number
+  isClosed: boolean
+  lineCount: number
+  getText: () => string
+  lineAt: (line: number) => { text: string, lineNumber: number, range: Range }
+  getWordRangeAtPosition: (position: Position) => Range | undefined
+}
+
+export function document(path: string, text: string, languageId = 'typescript'): FakeDocument {
+  const lines = text.split('\n')
+  return {
+    uri: { fsPath: path, scheme: 'file', toString: () => `file://${path}` },
+    languageId,
+    version: 1,
+    isClosed: false,
+    lineCount: lines.length,
+    getText: () => text,
+    lineAt: (line: number) => ({ text: lines[line] ?? '', lineNumber: line, range: new Range(line, 0, line, (lines[line] ?? '').length) }),
+    getWordRangeAtPosition: (position: Position) => {
+      const line = lines[position.line] ?? ''
+      const match = /\w+/.exec(line.slice(position.character))
+      return match && match.index === 0 ? new Range(position.line, position.character, position.line, position.character + match[0].length) : undefined
+    },
+  }
+}
+
+export function fakeVscode(options: { folders: string[], settings?: Record<string, unknown>, documents?: FakeDocument[] }) {
+  const settings = options.settings ?? {}
+  const diagnostics = new Map<string, any[]>()
+  const handlers = new Map<string, (...args: any[]) => any>()
+  const codeActionProviders: any[] = []
+  const formatters: any[] = []
+  const hovers: any[] = []
+  const messages: string[] = []
+  const answers: Array<string | undefined> = []
+  const inputs: any[] = []
+  const output: string[] = []
+  const applied: WorkspaceEdit[] = []
+  const clipboard: string[] = []
+  const opened = emitter<FakeDocument>()
+  const changed = emitter<{ document: FakeDocument }>()
+  const saved = emitter<FakeDocument>()
+  const closed = emitter<FakeDocument>()
+
+  const message = (text: string) => {
+    messages.push(text)
+    return Promise.resolve(answers.shift())
+  }
+
+  const api = {
+    Position,
+    Range,
+    CodeActionKind,
+    WorkspaceEdit,
+    MarkdownString,
+    DiagnosticSeverity: { Error: 0, Warning: 1, Information: 2, Hint: 3 },
+    Diagnostic: class {
+      source?: string
+      code?: string
+      constructor(readonly range: Range, readonly message: string, readonly severity: number) {}
+    },
+    CodeAction: class {
+      edit?: WorkspaceEdit
+      diagnostics?: unknown[]
+      constructor(readonly title: string, readonly kind: CodeActionKind) {}
+    },
+    Hover: class {
+      constructor(readonly contents: MarkdownString, readonly range?: Range) {}
+    },
+    TextEdit: { replace: (range: Range, newText: string) => ({ range, newText }) },
+    commands: {
+      registerCommand: (id: string, handler: (...args: any[]) => any) => {
+        handlers.set(id, handler)
+        return { dispose: () => handlers.delete(id) }
+      },
+    },
+    env: { clipboard: { writeText: async (text: string) => { clipboard.push(text) } } },
+    languages: {
+      createDiagnosticCollection: () => ({
+        set: (uri: { toString: () => string }, list: any[]) => diagnostics.set(uri.toString(), list),
+        delete: (uri: { toString: () => string }) => diagnostics.delete(uri.toString()),
+        clear: () => diagnostics.clear(),
+        dispose: () => {},
+      }),
+      registerCodeActionsProvider: (_selector: unknown, provider: unknown) => {
+        codeActionProviders.push(provider)
+        return { dispose: () => {} }
+      },
+      registerDocumentFormattingEditProvider: (_selector: unknown, provider: unknown) => {
+        formatters.push(provider)
+        return { dispose: () => {} }
+      },
+      registerHoverProvider: (_selector: unknown, provider: unknown) => {
+        hovers.push(provider)
+        return { dispose: () => {} }
+      },
+    },
+    window: {
+      activeTextEditor: undefined as undefined | { document: FakeDocument },
+      createOutputChannel: () => ({ appendLine: (line: string) => output.push(line), dispose: () => {} }),
+      showInformationMessage: message,
+      showWarningMessage: message,
+      showErrorMessage: message,
+      showInputBox: (inputOptions: unknown) => {
+        inputs.push(inputOptions)
+        return Promise.resolve(answers.shift())
+      },
+      showQuickPick: (items: string[], pickOptions: unknown) => {
+        inputs.push({ items, ...pickOptions as object })
+        return Promise.resolve(answers.shift())
+      },
+    },
+    workspace: {
+      workspaceFolders: options.folders.map((folder, index) => ({ uri: { fsPath: folder }, name: folder, index })),
+      textDocuments: options.documents ?? [],
+      getConfiguration: () => ({ get: (key: string, fallback: unknown) => key in settings ? settings[key] : fallback }),
+      getWorkspaceFolder: (uri: { fsPath: string }) => {
+        const folder = options.folders.find(candidate => uri.fsPath.startsWith(`${candidate}/`))
+        return folder ? { uri: { fsPath: folder } } : undefined
+      },
+      applyEdit: async (edit: WorkspaceEdit) => {
+        applied.push(edit)
+        return true
+      },
+      onDidOpenTextDocument: opened.event,
+      onDidChangeTextDocument: changed.event,
+      onDidSaveTextDocument: saved.event,
+      onDidCloseTextDocument: closed.event,
+      onDidChangeConfiguration: emitter<any>().event,
+    },
+  }
+
+  return {
+    api,
+    diagnostics,
+    handlers,
+    codeActionProviders,
+    formatters,
+    hovers,
+    messages,
+    answers,
+    inputs,
+    output,
+    applied,
+    clipboard,
+    events: { opened, changed, saved, closed },
+    context: { subscriptions: [] as Array<{ dispose: () => unknown }> },
+  }
+}
+
+export const flush = () => new Promise(resolve => setTimeout(resolve, 10))

package/ide/vscode/tests/manifest.test.ts

@@ -0,0 +1,88 @@
+/**
+ * The extension manifest.
+ *
+ * The Stacks extension is self-contained: stx support, pickier and env files
+ * are built in, so it installs no extension pack and depends on no other
+ * extension. stx support comes from `@stacksjs/stx-vscode`, the library build
+ * of the stx extension (Stacks.vscode-stx); with both installed, the stx
+ * extension stands down (stacksjs/stx#2020).
+ */
+import { describe, expect, it } from 'bun:test'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { libraryContributes, withStxContributes } from '../scripts/stx-contributes'
+
+const root = join(import.meta.dir, '..')
+const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+const STX_EXTENSION_ID = 'Stacks.vscode-stx'
+const projectSettings = Bun.JSONC.parse(readFileSync(join(root, '.vscode/settings.json'), 'utf8')) as Record<string, any>
+const recommendations = (Bun.JSONC.parse(readFileSync(join(root, '.vscode/extensions.json'), 'utf8')) as { recommendations: string[] }).recommendations
+
+describe('marketplace identity', () => {
+  it('is Stacks.vscode-stacks, not the stx extension', () => {
+    const id = `${manifest.publisher}.${manifest.name}`
+    expect(id).toBe('Stacks.vscode-stacks')
+    expect(id.toLowerCase()).not.toBe(STX_EXTENSION_ID.toLowerCase())
+  })
+})
+
+describe('self-contained', () => {
+  it('installs no extension pack and depends on no extension', () => {
+    expect(manifest.extensionPack).toBeUndefined()
+    expect(manifest.extensionDependencies).toBeUndefined()
+  })
+
+  it('has no runtime dependencies to ship', () => {
+    expect(manifest.dependencies).toBeUndefined()
+  })
+
+  it('recommends only itself to new projects', () => {
+    expect(recommendations.map(id => id.toLowerCase())).toEqual(['stacks.vscode-stacks'])
+  })
+
+  it('configures new projects for no other extension', () => {
+    // Settings that only mean something to an extension the project no longer
+    // asks for: ESLint, Prettier, Biome, markdownlint, shell-format, cSpell,
+    // Grammarly, vscode-icons, Todo Tree.
+    const foreign = Object.keys(projectSettings).filter(key =>
+      /^(?:eslint|prettier|biome|markdownlint|cSpell|grammarly|vsicons|todo-tree)\./.test(key))
+    expect(foreign).toEqual([])
+    expect(JSON.stringify(projectSettings)).not.toMatch(/dbaeumer|foxundermoon|DavidAnson|esbenp/i)
+  })
+
+  it('formats and fixes with pickier through this extension', () => {
+    expect(projectSettings['editor.defaultFormatter']).toBe('Stacks.vscode-stacks')
+    expect(projectSettings['editor.codeActionsOnSave']['source.fixAll.pickier']).toBe('explicit')
+  })
+})
+
+describe('stx language support', () => {
+  it('declares what @stacksjs/stx-vscode ships (run `bun run sync:stx` after updating it)', () => {
+    expect(withStxContributes(manifest, libraryContributes(root))).toEqual(manifest)
+  })
+
+  it('declares the stx language and its grammar from the bundled assets', () => {
+    expect(manifest.contributes.languages.map((language: { id: string }) => language.id)).toContain('stx')
+    expect(manifest.contributes.grammars[0].path).toStartWith('./dist/stx/')
+    expect(manifest.files).toContain('dist/stx/**')
+    expect(manifest.activationEvents).toContain('onLanguage:stx')
+  })
+
+  it('leaves snippets to runtime, so they never show twice next to the stx extension', () => {
+    expect(manifest.contributes.snippets).toBeUndefined()
+  })
+
+  it('does not map .stx files to another language', () => {
+    const extensionDefaults = manifest.contributes.configurationDefaults['files.associations'] ?? {}
+    for (const associations of [extensionDefaults, projectSettings['files.associations'] ?? {}])
+      expect(Object.keys(associations).filter(pattern => pattern.endsWith('.stx'))).toEqual([])
+  })
+})
+
+describe('packaging', () => {
+  it('ships the files the extension loads at runtime', () => {
+    for (const file of ['dist/extension.js', 'dist/pickier-worker.js', 'dist/pickier-worker.bunfig.toml'])
+      expect(manifest.files).toContain(file)
+    expect(manifest.main).toBe('./dist/extension.js')
+  })
+})