feat: add schema.secret type

Author: thetutlage

src/env.ts

@@ -7,12 +7,12 @@
  * file that was distributed with this source code.
  */
 
-import { schema as envSchema } from '@poppinss/validator-lite'
 import type { ValidateFn } from '@poppinss/validator-lite/types'
 
 import { EnvParser } from './parser.ts'
 import { EnvValidator } from './validator.ts'
 import { EnvProcessor } from './processor.ts'
+import { schema as envSchema } from './schema.ts'
 
 /**
  * A wrapper over "process.env" with types information.

src/parser.ts

@@ -7,11 +7,12 @@
  * file that was distributed with this source code.
  */
 
+import { readFile } from 'node:fs/promises'
 import dotenv, { type DotenvParseOutput } from 'dotenv'
+import { RuntimeException } from '@poppinss/utils/exception'
+
 import { type EnvIdentifierCallback } from './types.ts'
 import { E_IDENTIFIER_ALREADY_DEFINED } from './errors.ts'
-import { readFile } from 'node:fs/promises'
-import { RuntimeException } from '@poppinss/utils/exception'
 
 /**
  * Env parser parses the environment variables from a string formatted

src/schema.ts

@@ -0,0 +1,60 @@
+/*
+ * @adonisjs/env
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Secret } from '@poppinss/utils'
+import { type Prettify } from '@poppinss/utils/types'
+import { schema as envSchema } from '@poppinss/validator-lite'
+import { type SchemaFnOptions } from '@poppinss/validator-lite/types'
+
+function secret(options?: SchemaFnOptions) {
+  return function validate(key: string, value?: string): Secret<string> {
+    if (!value) {
+      throw new Error(options?.message ?? `Missing environment variable "${key}"`)
+    }
+    return new Secret(value)
+  }
+}
+
+/**
+ * Same as the Secret rule, but allows non-existing values too
+ */
+secret.optional = function optionalString() {
+  return function validate(_: string, value?: string): Secret<string> | undefined {
+    if (!value) {
+      return undefined
+    }
+    return new Secret(value)
+  }
+}
+
+/**
+ * Same as the optional rule, but allows a condition to decide when to
+ * validate the value
+ */
+secret.optionalWhen = function optionalWhenString(
+  condition: boolean | ((key: string, value?: string) => boolean),
+  options?: SchemaFnOptions
+) {
+  return function validate(key: string, value?: string): Secret<string> | undefined {
+    if (typeof condition === 'function' ? condition(key, value) : condition) {
+      return secret.optional()(key, value)
+    }
+
+    return secret(options)(key, value)
+  }
+}
+
+export const schema: Prettify<
+  typeof envSchema & {
+    secret: typeof secret
+  }
+> = {
+  ...envSchema,
+  secret,
+}

tests/validator.spec.ts

@@ -9,9 +9,11 @@
 
 import { test } from '@japa/runner'
 import string from '@poppinss/utils/string'
-import { schema } from '@poppinss/validator-lite'
+
+import { schema } from '../src/schema.ts'
 import { EnvValidator } from '../src/validator.ts'
 import { E_INVALID_ENV_VARIABLES } from '../src/errors.ts'
+import { Secret } from '@poppinss/utils'
 
 test.group('Env Validator', () => {
   test('validate values against pre-defined schema', async ({ assert, expectTypeOf }) => {
@@ -103,4 +105,18 @@ test.group('Env Validator', () => {
     expectTypeOf(output).toEqualTypeOf<{ PORT: number }>()
     assert.deepEqual(output, { PORT: 3333 })
   })
+
+  test('convert value to a secret', async ({ assert, expectTypeOf }) => {
+    const validator = new EnvValidator({
+      PASSWORD: schema.secret(),
+    })
+
+    const values = { PASSWORD: 'helloworld' }
+    const output = validator.validate(values)
+    expectTypeOf(output).toEqualTypeOf<{ PASSWORD: Secret<string> }>()
+
+    assert.instanceOf(output.PASSWORD, Secret)
+    assert.equal(output.PASSWORD.release(), 'helloworld')
+    assert.deepEqual(values, { PASSWORD: 'helloworld' })
+  })
 })