TypeScript schema.object方法代碼示例

jest.mock('../layouts/layouts', () => {
  const { schema } = require('@kbn/config-schema');
  return {
    Layouts: {
      configSchema: schema.object({ kind: schema.literal('mock') }),
      create: mockCreateLayout,
    },
  };
});

test('correctly passes context', async () => {
  mockPackage.raw = {
    branch: 'feature-v1',
    version: 'v1',
    build: {
      distributable: true,
      number: 100,
      sha: 'feature-v1-build-sha',
    },
  };

  const env = new Env('/kibana', getEnvOptions());

  const config$ = new BehaviorSubject(new ObjectToConfigAdapter({ foo: {} }));
  const schemaDefinition = schema.object({
    branchRef: schema.string({
      defaultValue: schema.contextRef('branch'),
    }),
    buildNumRef: schema.number({
      defaultValue: schema.contextRef('buildNum'),
    }),
    buildShaRef: schema.string({
      defaultValue: schema.contextRef('buildSha'),
    }),
    devRef: schema.boolean({ defaultValue: schema.contextRef('dev') }),
    prodRef: schema.boolean({ defaultValue: schema.contextRef('prod') }),
    versionRef: schema.string({
      defaultValue: schema.contextRef('version'),
    }),
  });
  const configService = new ConfigService(config$, env, logger);
  await configService.setSchema('foo', schemaDefinition);
  const value$ = configService.atPath('foo');

  expect(await value$.pipe(first()).toPromise()).toMatchSnapshot();
});

 schema: schema.object({
   sniffOnStart: schema.boolean({ defaultValue: false }),
   sniffInterval: schema.oneOf([schema.duration(), schema.literal(false)], {
     defaultValue: false,
   }),
   sniffOnConnectionFault: schema.boolean({ defaultValue: false }),
   hosts: schema.oneOf([hostURISchema, schema.arrayOf(hostURISchema, { minSize: 1 })], {
     defaultValue: 'http://localhost:9200',
   }),
   preserveHost: schema.boolean({ defaultValue: true }),
   username: schema.maybe(schema.string()),
   password: schema.maybe(schema.string()),
   requestHeadersWhitelist: schema.oneOf([schema.string(), schema.arrayOf(schema.string())], {
     defaultValue: ['authorization'],
   }),
   customHeaders: schema.recordOf(schema.string(), schema.string(), { defaultValue: {} }),
   shardTimeout: schema.duration({ defaultValue: '30s' }),
   requestTimeout: schema.duration({ defaultValue: '30s' }),
   pingTimeout: schema.duration({ defaultValue: schema.siblingRef('requestTimeout') }),
   startupTimeout: schema.duration({ defaultValue: '5s' }),
   logQueries: schema.boolean({ defaultValue: false }),
   ssl: schema.object({
     verificationMode: schema.oneOf(
       [schema.literal('none'), schema.literal('certificate'), schema.literal('full')],
       { defaultValue: 'full' }
     ),
     certificateAuthorities: schema.maybe(
       schema.oneOf([schema.string(), schema.arrayOf(schema.string(), { minSize: 1 })])
     ),
     certificate: schema.maybe(schema.string()),
     key: schema.maybe(schema.string()),
     keyPassphrase: schema.maybe(schema.string()),
     alwaysPresentCertificate: schema.boolean({ defaultValue: true }),
   }),
   apiVersion: schema.string({ defaultValue: DEFAULT_API_VERSION }),
   healthCheck: schema.object({ delay: schema.duration({ defaultValue: 2500 }) }),
 }),

 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import { schema, TypeOf } from '@kbn/config-schema';

export const config = {
  path: 'dev',
  schema: schema.object({
    basePathProxyTarget: schema.number({
      defaultValue: 5603,
    }),
  }),
};

export type DevConfigType = TypeOf<typeof config.schema>;

export class DevConfig {
  public basePathProxyTargetPort: number;

  /**
   * @internal
   */
  constructor(rawConfig: DevConfigType) {
    this.basePathProxyTargetPort = rawConfig.basePathProxyTarget;
  }

]);

export const sslSchema = schema.object(
  {
    certificate: schema.maybe(schema.string()),
    certificateAuthorities: schema.maybe(
      schema.oneOf([schema.arrayOf(schema.string()), schema.string()])
    ),
    cipherSuites: schema.arrayOf(schema.string(), {
      defaultValue: cryptoConstants.defaultCoreCipherList.split(':'),
    }),
    enabled: schema.boolean({
      defaultValue: false,
    }),
    key: schema.maybe(schema.string()),
    keyPassphrase: schema.maybe(schema.string()),
    redirectHttpFromPort: schema.maybe(schema.number()),
    supportedProtocols: schema.arrayOf(
      schema.oneOf([schema.literal('TLSv1'), schema.literal('TLSv1.1'), schema.literal('TLSv1.2')]),
      { defaultValue: ['TLSv1.1', 'TLSv1.2'], minSize: 1 }
    ),
  },
  {
    validate: ssl => {
      if (ssl.enabled && (!ssl.key || !ssl.certificate)) {
        return 'must specify [certificate] and [key] when ssl is enabled';
      }
    },
  }
);

type SslConfigType = TypeOf<typeof sslSchema>;

 * specific language governing permissions and limitations
 * under the License.
 */

import { schema, TypeOf } from '@kbn/config-schema';
import { Env } from '../config';

export type PluginsConfigType = TypeOf<typeof config.schema>;

export const config = {
  path: 'plugins',
  schema: schema.object({
    initialize: schema.boolean({ defaultValue: true }),

    /**
     * Defines an array of directories where another plugin should be loaded from.
     * Should only be used in a development environment.
     */
    paths: schema.arrayOf(schema.string(), { defaultValue: [] }),
  }),
};

/** @internal */
export class PluginsConfig {
  /**
   * Indicates whether or not plugins should be initialized.
   */
  public readonly initialize: boolean;

  /**
   * Defines directories that we should scan for the plugin subdirectories.

  schema: schema.object(
    {
      autoListen: schema.boolean({ defaultValue: true }),
      basePath: schema.maybe(
        schema.string({
          validate: match(validBasePathRegex, "must start with a slash, don't end with one"),
        })
      ),
      cors: schema.conditional(
        schema.contextRef('dev'),
        true,
        schema.object(
          {
            origin: schema.arrayOf(schema.string()),
          },
          {
            defaultValue: {
              origin: ['*://localhost:9876'], // karma test server
            },
          }
        ),
        schema.boolean({ defaultValue: false })
      ),
      host: schema.string({
        defaultValue: 'localhost',
        hostname: true,
      }),
      maxPayload: schema.byteSize({
        defaultValue: '1048576b',
      }),
      port: schema.number({
        defaultValue: 5601,
      }),
      rewriteBasePath: schema.boolean({ defaultValue: false }),
      ssl: sslSchema,
    },
    {
      validate: rawConfig => {
        if (!rawConfig.basePath && rawConfig.rewriteBasePath) {
          return 'cannot use [rewriteBasePath] when [basePath] is not specified';
        }

        if (
          rawConfig.ssl.enabled &&
          rawConfig.ssl.redirectHttpFromPort !== undefined &&
          rawConfig.ssl.redirectHttpFromPort === rawConfig.port
        ) {
          return (
            'Kibana does not accept http traffic to [port] when ssl is ' +
            'enabled (only https is allowed), so [ssl.redirectHttpFromPort] ' +
            `cannot be configured to the same value. Both are [${rawConfig.port}].`
          );
        }
      },
    }
  ),

 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import { map, mergeMap } from 'rxjs/operators';
import { schema, TypeOf } from '@kbn/config-schema';

import { CoreSetup, CoreStart, Logger, PluginInitializerContext, PluginName } from 'kibana/server';

export const config = {
  schema: schema.object({
    secret: schema.string({ defaultValue: 'Not really a secret :/' }),
  }),
};

type ConfigType = TypeOf<typeof config.schema>;

class Plugin {
  private readonly log: Logger;

  constructor(private readonly initializerContext: PluginInitializerContext) {
    this.log = this.initializerContext.logger.get();
  }

  public setup(core: CoreSetup, deps: Record<PluginName, unknown>) {
    this.log.debug(
      `Setting up TestBed with core contract [${Object.keys(core)}] and deps [${Object.keys(deps)}]`