json-schema#JSONSchema4 TypeScript Examples
The following examples show how to use
json-schema#JSONSchema4.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
| Source File: generateTypes.ts From payload with MIT License | 6 votes |
|
function entityToJsonSchema(config: SanitizedConfig, entity: SanitizedCollectionConfig | SanitizedGlobalConfig): JSONSchema4 {
const title = 'label' in entity ? entity.label : entity.labels.singular;
const idField: FieldAffectingData = { type: 'text', name: 'id', required: true };
const customIdField = entity.fields.find((field) => fieldAffectsData(field) && field.name === 'id') as FieldAffectingData;
if (customIdField) {
customIdField.required = true;
} else {
entity.fields.unshift(idField);
}
return {
title,
type: 'object',
additionalProperties: false,
...generateFieldTypes(config, entity.fields),
};
}
Example #2
| Source File: generateTypes.ts From payload with MIT License | 6 votes |
|
function configToJsonSchema(config: SanitizedConfig): JSONSchema4 {
return {
definitions: Object.fromEntries(
[
...config.globals.map((global) => [
global.slug,
entityToJsonSchema(config, global),
]),
...config.collections.map((collection) => [
collection.slug,
entityToJsonSchema(config, collection),
]),
],
),
additionalProperties: false,
};
}
Example #3
| Source File: schema.ts From dataset with The Unlicense | 6 votes |
|
async function main() {
await fs.mkdir('./dist/schema', { recursive: true });
const bundleSchema = await $RefParser.dereference('./schema/bundle.json');
const individualSchema = await $RefParser.dereference('./schema/individual.json');
await fs.writeFile('./src/types/bundle.d.ts', await compile(bundleSchema as JSONSchema4, 'BundleProposals'));
await fs.writeFile('./src/types/individual.d.ts', await compile(individualSchema as JSONSchema4, 'IndividualProposal'));
await fs.writeFile('./dist/schema/bundle.json', JSON.stringify(bundleSchema, null, 2));
await fs.writeFile('./dist/schema/individual.json', JSON.stringify(individualSchema, null, 2));
}
Example #4
| Source File: graphql-js-validation.ts From graphql-eslint with MIT License | 5 votes |
|
validationToRule = (
ruleId: string,
ruleName: string,
docs: GraphQLESLintRule['meta']['docs'],
getDocumentNode?: GetDocumentNode,
schema: JSONSchema4 | JSONSchema4[] = []
): Record<typeof ruleId, GraphQLESLintRule<any, true>> => {
let ruleFn: null | ValidationRule = null;
try {
ruleFn = require(`graphql/validation/rules/${ruleName}Rule`)[`${ruleName}Rule`];
} catch {
try {
ruleFn = require(`graphql/validation/rules/${ruleName}`)[`${ruleName}Rule`];
} catch {
ruleFn = require('graphql/validation')[`${ruleName}Rule`];
}
}
return {
[ruleId]: {
meta: {
docs: {
recommended: true,
...docs,
graphQLJSRuleName: ruleName,
url: `https://github.com/B2o5T/graphql-eslint/blob/master/docs/rules/${ruleId}.md`,
description: `${docs.description}\n\n> This rule is a wrapper around a \`graphql-js\` validation function.`,
},
schema,
},
create(context) {
if (!ruleFn) {
logger.warn(
`Rule "${ruleId}" depends on a GraphQL validation rule "${ruleName}" but it's not available in the "graphql" version you are using. Skipping…`
);
return {};
}
return {
Document(node) {
const schema = docs.requiresSchema ? requireGraphQLSchemaFromContext(ruleId, context) : null;
const documentNode = getDocumentNode
? getDocumentNode({ ruleId, context, node: node.rawNode() })
: node.rawNode();
validateDocument(context, schema, documentNode, ruleFn);
},
};
},
},
};
}
Example #5
| Source File: index.ts From contracts-ui with GNU General Public License v3.0 | 5 votes |
|
user = userSchema as JSONSchema4
Example #6
| Source File: index.ts From contracts-ui with GNU General Public License v3.0 | 5 votes |
|
codeBundle = codeBundleSchema as JSONSchema4
Example #7
| Source File: index.ts From contracts-ui with GNU General Public License v3.0 | 5 votes |
|
contract = contractSchema as JSONSchema4
Example #8
| Source File: generateTypes.ts From payload with MIT License | 4 votes |
|
function generateFieldTypes(config: SanitizedConfig, fields: Field[]): {
properties: {
[k: string]: JSONSchema4;
}
required: string[]
} {
let topLevelProps = [];
let requiredTopLevelProps = [];
return {
properties: Object.fromEntries(
fields.reduce((properties, field) => {
let fieldSchema: JSONSchema4;
switch (field.type) {
case 'text':
case 'textarea':
case 'code':
case 'email':
case 'date': {
fieldSchema = { type: 'string' };
break;
}
case 'number': {
fieldSchema = { type: 'number' };
break;
}
case 'checkbox': {
fieldSchema = { type: 'boolean' };
break;
}
case 'richText': {
fieldSchema = {
type: 'array',
items: {
type: 'object',
},
};
break;
}
case 'radio': {
fieldSchema = {
type: 'string',
enum: returnOptionEnums(field.options),
};
break;
}
case 'select': {
const selectType: JSONSchema4 = {
type: 'string',
enum: returnOptionEnums(field.options),
};
if (field.hasMany) {
fieldSchema = {
type: 'array',
items: selectType,
};
} else {
fieldSchema = selectType;
}
break;
}
case 'point': {
fieldSchema = {
type: 'array',
minItems: 2,
maxItems: 2,
items: [
{
type: 'number',
},
{
type: 'number',
},
],
};
break;
}
case 'relationship': {
if (Array.isArray(field.relationTo)) {
if (field.hasMany) {
fieldSchema = {
type: 'array',
items: {
oneOf: field.relationTo.map((relation) => {
const idFieldType = getCollectionIDType(config.collections, relation);
return {
type: 'object',
additionalProperties: false,
properties: {
value: {
oneOf: [
{
type: idFieldType,
},
{
$ref: `#/definitions/${relation}`,
},
],
},
relationTo: {
const: relation,
},
},
required: ['value', 'relationTo'],
};
}),
},
};
} else {
fieldSchema = {
oneOf: field.relationTo.map((relation) => {
const idFieldType = getCollectionIDType(config.collections, relation);
return {
type: 'object',
additionalProperties: false,
properties: {
value: {
oneOf: [
{
type: idFieldType,
},
{
$ref: `#/definitions/${relation}`,
},
],
},
relationTo: {
const: relation,
},
},
required: ['value', 'relationTo'],
};
}),
};
}
} else {
const idFieldType = getCollectionIDType(config.collections, field.relationTo);
if (field.hasMany) {
fieldSchema = {
type: 'array',
items: {
oneOf: [
{
type: idFieldType,
},
{
$ref: `#/definitions/${field.relationTo}`,
},
],
},
};
} else {
fieldSchema = {
oneOf: [
{
type: idFieldType,
},
{
$ref: `#/definitions/${field.relationTo}`,
},
],
};
}
}
break;
}
case 'upload': {
const idFieldType = getCollectionIDType(config.collections, field.relationTo);
fieldSchema = {
oneOf: [
{
type: idFieldType,
},
{
$ref: `#/definitions/${field.relationTo}`,
},
],
};
break;
}
case 'blocks': {
fieldSchema = {
type: 'array',
items: {
oneOf: field.blocks.map((block) => {
const blockSchema = generateFieldTypes(config, block.fields);
return {
type: 'object',
additionalProperties: false,
properties: {
...blockSchema.properties,
blockType: {
const: block.slug,
},
},
required: [
'blockType',
...blockSchema.required,
],
};
}),
},
};
break;
}
case 'array': {
fieldSchema = {
type: 'array',
items: {
type: 'object',
additionalProperties: false,
...generateFieldTypes(config, field.fields),
},
};
break;
}
case 'row': {
const topLevelFields = generateFieldTypes(config, field.fields);
requiredTopLevelProps = requiredTopLevelProps.concat(topLevelFields.required);
topLevelProps = topLevelProps.concat(Object.entries(topLevelFields.properties).map((prop) => prop));
break;
}
case 'group': {
fieldSchema = {
type: 'object',
additionalProperties: false,
...generateFieldTypes(config, field.fields),
};
break;
}
default: {
break;
}
}
if (fieldSchema && fieldAffectsData(field)) {
return [
...properties,
[
field.name,
{
...fieldSchema,
},
],
];
}
return [
...properties,
...topLevelProps,
];
}, []),
),
required: [
...fields
.filter((field) => fieldAffectsData(field) && field.required === true)
.map((field) => (fieldAffectsData(field) ? field.name : '')),
...requiredTopLevelProps,
],
};
}
