@sanity/codegen 3.86.2-experimental.0 → 3.87.1-canary.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/index.d.mts +91 -79
- package/lib/index.d.ts +91 -79
- package/lib/index.js +151 -492
- package/lib/index.js.map +1 -1
- package/lib/index.mjs +152 -493
- package/lib/index.mjs.map +1 -1
- package/package.json +17 -15
- package/src/_exports/index.ts +3 -16
- package/src/readConfig.ts +19 -77
- package/src/typescript/expressionResolvers.ts +3 -4
- package/src/typescript/findQueriesInPath.ts +2 -2
- package/src/typescript/findQueriesInSource.ts +5 -25
- package/src/typescript/typeGenerator.ts +374 -0
- package/src/typescript/asyncQueue.ts +0 -100
- package/src/typescript/generateTypes.ts +0 -425
- package/src/typescript/schemaTypeGenerator.ts +0 -415
package/lib/index.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: !0 });
|
|
3
|
-
var fs = require("node:fs/promises"), json5 = require("json5"), z = require("zod"), groqJs = require("groq-js"), createDebug = require("debug"), glob = require("globby"), fs$1 = require("node:fs"), path = require("node:path"), node_module = require("node:module"), core = require("@babel/core"), t = require("@babel/types"), traverse = require("@babel/traverse"), tsconfigPaths = require("tsconfig-paths"),
|
|
3
|
+
var fs = require("node:fs/promises"), json5 = require("json5"), z = require("zod"), groqJs = require("groq-js"), createDebug = require("debug"), glob = require("globby"), fs$1 = require("node:fs"), path = require("node:path"), node_module = require("node:module"), core = require("@babel/core"), t = require("@babel/types"), traverse = require("@babel/traverse"), tsconfigPaths = require("tsconfig-paths"), register = require("@babel/register"), generator = require("@babel/generator");
|
|
4
4
|
function _interopDefaultCompat(e) {
|
|
5
5
|
return e && typeof e == "object" && "default" in e ? e : { default: e };
|
|
6
6
|
}
|
|
@@ -20,54 +20,28 @@ function _interopNamespaceCompat(e) {
|
|
|
20
20
|
}), n.default = e, Object.freeze(n);
|
|
21
21
|
}
|
|
22
22
|
var fs__default$1 = /* @__PURE__ */ _interopDefaultCompat(fs), json5__namespace = /* @__PURE__ */ _interopNamespaceCompat(json5), z__namespace = /* @__PURE__ */ _interopNamespaceCompat(z), createDebug__default = /* @__PURE__ */ _interopDefaultCompat(createDebug), glob__default = /* @__PURE__ */ _interopDefaultCompat(glob), fs__default = /* @__PURE__ */ _interopDefaultCompat(fs$1), path__default = /* @__PURE__ */ _interopDefaultCompat(path), t__namespace = /* @__PURE__ */ _interopNamespaceCompat(t), traverse__default = /* @__PURE__ */ _interopDefaultCompat(traverse), register__default = /* @__PURE__ */ _interopDefaultCompat(register);
|
|
23
|
-
const
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
schemas: z__namespace.array(
|
|
35
|
-
z__namespace.object({
|
|
36
|
-
projectId: z__namespace.string().optional(),
|
|
37
|
-
dataset: z__namespace.string().optional(),
|
|
38
|
-
schemaPath: z__namespace.string()
|
|
39
|
-
})
|
|
40
|
-
).optional()
|
|
41
|
-
}).superRefine((data, ctx) => {
|
|
42
|
-
data.schema !== void 0 && data.schemas !== void 0 && ctx.addIssue({
|
|
43
|
-
code: z__namespace.ZodIssueCode.custom,
|
|
44
|
-
message: 'Configuration cannot contain both "schema" and "schemas". Use one or the other.'
|
|
45
|
-
});
|
|
46
|
-
}).refine((d) => d.schemas === void 0 || d.schemas.length > 0, {
|
|
47
|
-
message: '"schemas" array cannot be empty. Please provide at least one schema definition or use the "schema" property instead.'
|
|
48
|
-
}), normalizedConfigSchema = rawConfigSchema.transform((d) => ({
|
|
49
|
-
path: typeof d.path == "string" ? [d.path] : d.path ?? defaultPaths,
|
|
50
|
-
generates: d.generates ?? "./sanity.types.ts",
|
|
51
|
-
formatGeneratedCode: d.formatGeneratedCode ?? !0,
|
|
52
|
-
overloadClientMethods: d.overloadClientMethods ?? !0,
|
|
53
|
-
augmentGroqModule: d.augmentGroqModule ?? !0,
|
|
54
|
-
schemas: d.schemas ? d.schemas.map((s) => ({
|
|
55
|
-
projectId: s.projectId ?? "default",
|
|
56
|
-
dataset: s.dataset ?? "default",
|
|
57
|
-
schemaPath: s.schemaPath
|
|
58
|
-
})) : [{ projectId: "default", dataset: "default", schemaPath: d.schema ?? "./schema.json" }]
|
|
59
|
-
}));
|
|
23
|
+
const configDefintion = z__namespace.object({
|
|
24
|
+
path: z__namespace.string().or(z__namespace.array(z__namespace.string())).default([
|
|
25
|
+
"./src/**/*.{ts,tsx,js,jsx,mjs,cjs,astro}",
|
|
26
|
+
"./app/**/*.{ts,tsx,js,jsx,mjs,cjs}",
|
|
27
|
+
"./sanity/**/*.{ts,tsx,js,jsx,mjs,cjs}"
|
|
28
|
+
]),
|
|
29
|
+
schema: z__namespace.string().default("./schema.json"),
|
|
30
|
+
generates: z__namespace.string().default("./sanity.types.ts"),
|
|
31
|
+
formatGeneratedCode: z__namespace.boolean().default(!0),
|
|
32
|
+
overloadClientMethods: z__namespace.boolean().default(!0)
|
|
33
|
+
});
|
|
60
34
|
async function readConfig(path2) {
|
|
61
35
|
try {
|
|
62
36
|
const content = await fs.readFile(path2, "utf-8"), json = json5__namespace.parse(content);
|
|
63
|
-
return
|
|
37
|
+
return configDefintion.parseAsync(json);
|
|
64
38
|
} catch (error) {
|
|
65
39
|
if (error instanceof z__namespace.ZodError)
|
|
66
40
|
throw new Error(`Error in config file
|
|
67
41
|
${error.errors.map((err) => err.message).join(`
|
|
68
42
|
`)}`);
|
|
69
43
|
if (typeof error == "object" && error !== null && "code" in error && error.code === "ENOENT")
|
|
70
|
-
return
|
|
44
|
+
return configDefintion.parse({});
|
|
71
45
|
throw error;
|
|
72
46
|
}
|
|
73
47
|
}
|
|
@@ -121,7 +95,7 @@ function parseAstro(source) {
|
|
|
121
95
|
`)).join(`
|
|
122
96
|
`) : "";
|
|
123
97
|
}
|
|
124
|
-
const debug$2 = createDebug__default.default("sanity:codegen:findQueries:debug"), TAGGED_TEMPLATE_ALLOW_LIST = ["groq"], FUNCTION_WRAPPER_ALLOW_LIST = ["defineQuery"
|
|
98
|
+
const debug$2 = createDebug__default.default("sanity:codegen:findQueries:debug"), TAGGED_TEMPLATE_ALLOW_LIST = ["groq"], FUNCTION_WRAPPER_ALLOW_LIST = ["defineQuery"];
|
|
125
99
|
function resolveExpression({
|
|
126
100
|
node,
|
|
127
101
|
file,
|
|
@@ -431,23 +405,19 @@ function resolveExportSpecifier({
|
|
|
431
405
|
cause: `noBinding:${importName}`
|
|
432
406
|
});
|
|
433
407
|
}
|
|
434
|
-
const require$1 = node_module.createRequire(__filename), groqTagName = "groq", defineQueryFunctionName = "defineQuery",
|
|
408
|
+
const require$1 = node_module.createRequire(__filename), groqTagName = "groq", defineQueryFunctionName = "defineQuery", groqModuleName = "groq", nextSanityModuleName = "next-sanity", ignoreValue = "@sanity-typegen-ignore";
|
|
435
409
|
function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), resolver = require$1.resolve) {
|
|
436
410
|
const queries = [], file = parseSourceFile(source, filename, babelConfig);
|
|
437
411
|
return core.traverse(file, {
|
|
438
412
|
// Look for variable declarations, e.g. `const myQuery = groq`... and extract the query.
|
|
439
413
|
// The variable name is used as the name of the query result type
|
|
440
414
|
VariableDeclarator(path2) {
|
|
441
|
-
const { node, scope } = path2, init = node.init, isGroqTemplateTag = t__namespace.isTaggedTemplateExpression(init) && t__namespace.isIdentifier(init.tag) && init.tag.name === groqTagName,
|
|
442
|
-
if (t__namespace.isIdentifier(node.id) && (isGroqTemplateTag ||
|
|
415
|
+
const { node, scope } = path2, init = node.init, isGroqTemplateTag = t__namespace.isTaggedTemplateExpression(init) && t__namespace.isIdentifier(init.tag) && init.tag.name === groqTagName, isDefineQueryCall = t__namespace.isCallExpression(init) && (isImportFrom(groqModuleName, defineQueryFunctionName, scope, init.callee) || isImportFrom(nextSanityModuleName, defineQueryFunctionName, scope, init.callee));
|
|
416
|
+
if (t__namespace.isIdentifier(node.id) && (isGroqTemplateTag || isDefineQueryCall)) {
|
|
443
417
|
if (declarationLeadingCommentContains(path2, ignoreValue))
|
|
444
418
|
return;
|
|
445
|
-
const queryName = `${node.id.name}
|
|
446
|
-
|
|
447
|
-
isDefineCall && (init.arguments.length > 0 && t__namespace.isExpression(init.arguments[0]) && (expressionToResolve = init.arguments[0]), isImportFrom(groqModuleName, defineProjectionFunctionName, scope, init.callee) && (resultType = "projection"));
|
|
448
|
-
const queryResult = resolveExpression({
|
|
449
|
-
node: expressionToResolve,
|
|
450
|
-
// Use the potentially updated expression node
|
|
419
|
+
const queryName = `${node.id.name}`, queryResult = resolveExpression({
|
|
420
|
+
node: init,
|
|
451
421
|
file,
|
|
452
422
|
scope,
|
|
453
423
|
babelConfig,
|
|
@@ -461,7 +431,7 @@ function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), r
|
|
|
461
431
|
...node.loc?.end
|
|
462
432
|
}
|
|
463
433
|
} : {};
|
|
464
|
-
queries.push({ name: queryName, result: queryResult,
|
|
434
|
+
queries.push({ name: queryName, result: queryResult, location });
|
|
465
435
|
}
|
|
466
436
|
}
|
|
467
437
|
}), queries;
|
|
@@ -547,142 +517,120 @@ async function* findQueriesInPath({
|
|
|
547
517
|
}
|
|
548
518
|
}
|
|
549
519
|
}
|
|
550
|
-
|
|
551
|
-
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
|
|
560
|
-
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
520
|
+
function registerBabel(babelOptions) {
|
|
521
|
+
const options = babelOptions || getBabelConfig();
|
|
522
|
+
register__default.default({ ...options, extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] });
|
|
523
|
+
}
|
|
524
|
+
const REFERENCE_SYMBOL_NAME = "internalGroqTypeReferenceTo", ALL_SCHEMA_TYPES = "AllSanitySchemaTypes";
|
|
525
|
+
class TypeGenerator {
|
|
526
|
+
// Simple set to keep track of generated type names, to avoid conflicts
|
|
527
|
+
generatedTypeName = /* @__PURE__ */ new Set();
|
|
528
|
+
// Map between type names and their generated type names, used to resolve the correct generated type name
|
|
529
|
+
typeNameMap = /* @__PURE__ */ new Map();
|
|
530
|
+
// Map between type nodes and their generated type names, used for query mapping
|
|
531
|
+
typeNodeNameMap = /* @__PURE__ */ new Map();
|
|
532
|
+
schema;
|
|
533
|
+
constructor(schema) {
|
|
534
|
+
this.schema = schema, this.schema.forEach((s) => {
|
|
535
|
+
this.getTypeName(s.name, s);
|
|
536
|
+
});
|
|
567
537
|
}
|
|
568
538
|
/**
|
|
569
|
-
*
|
|
539
|
+
* Generate TypeScript types for the given schema
|
|
540
|
+
* @returns string
|
|
541
|
+
* @internal
|
|
542
|
+
* @beta
|
|
570
543
|
*/
|
|
571
|
-
|
|
572
|
-
|
|
544
|
+
generateSchemaTypes() {
|
|
545
|
+
const typeDeclarations = [], schemaNames = /* @__PURE__ */ new Set();
|
|
546
|
+
return this.schema.forEach((schema) => {
|
|
547
|
+
const typeLiteral = this.getTypeNodeType(schema), schemaName = this.typeNodeNameMap.get(schema);
|
|
548
|
+
if (!schemaName)
|
|
549
|
+
throw new Error(`Schema name not found for schema ${schema.name}`);
|
|
550
|
+
schemaNames.add(schemaName);
|
|
551
|
+
const typeAlias = t__namespace.tsTypeAliasDeclaration(t__namespace.identifier(schemaName), null, typeLiteral);
|
|
552
|
+
typeDeclarations.push(t__namespace.exportNamedDeclaration(typeAlias));
|
|
553
|
+
}), typeDeclarations.push(
|
|
554
|
+
t__namespace.exportNamedDeclaration(
|
|
555
|
+
t__namespace.tsTypeAliasDeclaration(
|
|
556
|
+
t__namespace.identifier(this.getTypeName(ALL_SCHEMA_TYPES)),
|
|
557
|
+
null,
|
|
558
|
+
t__namespace.tsUnionType(
|
|
559
|
+
[...schemaNames].map((typeName) => t__namespace.tsTypeReference(t__namespace.identifier(typeName)))
|
|
560
|
+
)
|
|
561
|
+
)
|
|
562
|
+
)
|
|
563
|
+
), typeDeclarations.map((decl) => new generator.CodeGenerator(decl).generate().code).join(`
|
|
564
|
+
|
|
565
|
+
`);
|
|
573
566
|
}
|
|
574
567
|
/**
|
|
575
|
-
*
|
|
568
|
+
* Takes a identifier and a type node and generates a type alias for the type node.
|
|
569
|
+
* @param identifierName - The name of the type to generated
|
|
570
|
+
* @param typeNode - The type node to generate the type for
|
|
571
|
+
* @returns
|
|
572
|
+
* @internal
|
|
573
|
+
* @beta
|
|
576
574
|
*/
|
|
577
|
-
|
|
578
|
-
|
|
575
|
+
generateTypeNodeTypes(identifierName, typeNode) {
|
|
576
|
+
const type = this.getTypeNodeType(typeNode), typeName = this.getTypeName(identifierName, typeNode), typeAlias = t__namespace.tsTypeAliasDeclaration(t__namespace.identifier(typeName), null, type);
|
|
577
|
+
return new generator.CodeGenerator(t__namespace.exportNamedDeclaration(typeAlias)).generate().code.trim();
|
|
578
|
+
}
|
|
579
|
+
static generateKnownTypes() {
|
|
580
|
+
const typeOperator = t__namespace.tsTypeOperator(t__namespace.tsSymbolKeyword());
|
|
581
|
+
typeOperator.operator = "unique";
|
|
582
|
+
const identifier = t__namespace.identifier(REFERENCE_SYMBOL_NAME);
|
|
583
|
+
identifier.typeAnnotation = t__namespace.tsTypeAnnotation(typeOperator);
|
|
584
|
+
const decleration = t__namespace.variableDeclaration("const", [t__namespace.variableDeclarator(identifier)]);
|
|
585
|
+
return decleration.declare = !0, new generator.CodeGenerator(t__namespace.exportNamedDeclaration(decleration)).generate().code.trim();
|
|
579
586
|
}
|
|
580
587
|
/**
|
|
581
|
-
*
|
|
582
|
-
*
|
|
588
|
+
* Takes a list of queries from the codebase and generates a type declaration
|
|
589
|
+
* for SanityClient to consume.
|
|
590
|
+
*
|
|
591
|
+
* Note: only types that have previously been generated with `generateTypeNodeTypes`
|
|
592
|
+
* will be included in the query map.
|
|
593
|
+
*
|
|
594
|
+
* @param queries - A list of queries to generate a type declaration for
|
|
595
|
+
* @returns
|
|
596
|
+
* @internal
|
|
597
|
+
* @beta
|
|
583
598
|
*/
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
this.resume = resolve;
|
|
590
|
-
}), this.pendingError))
|
|
591
|
-
throw this.pendingError;
|
|
592
|
-
for (; this.queue.length > 0; )
|
|
593
|
-
yield this.queue.shift();
|
|
594
|
-
if (this.finished && this.queue.length === 0)
|
|
595
|
-
break;
|
|
599
|
+
generateQueryMap(queries) {
|
|
600
|
+
const typesByQuerystring = {};
|
|
601
|
+
for (const query of queries) {
|
|
602
|
+
const name = this.typeNodeNameMap.get(query.typeNode);
|
|
603
|
+
name && (typesByQuerystring[query.query] ??= [], typesByQuerystring[query.query].push(name));
|
|
596
604
|
}
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
static REFERENCE_SYMBOL_NAME = "internalGroqTypeReferenceTo";
|
|
615
|
-
static sanitizeIdentifier(input) {
|
|
616
|
-
return uppercaseFirstLetter(sanitizeIdentifier(input));
|
|
617
|
-
}
|
|
618
|
-
constructor({ dataset, projectId, schema }) {
|
|
619
|
-
this.dataset = dataset, this.projectId = projectId, this.schema = schema;
|
|
620
|
-
const sanitizedCounts = {};
|
|
621
|
-
this.identifiers = this.schema.reduce((acc, { name }) => {
|
|
622
|
-
const base = SchemaTypeGenerator.sanitizeIdentifier(name), count = (sanitizedCounts[base] || 0) + 1;
|
|
623
|
-
sanitizedCounts[base] = count;
|
|
624
|
-
const uniqueName = count === 1 ? base : `${base}_${count}`;
|
|
625
|
-
return acc.set(name, t__namespace.identifier(uniqueName)), acc;
|
|
626
|
-
}, /* @__PURE__ */ new Map()), this.documentTypeNames = new Set(schema.filter((i) => i.type === "document").map((i) => i.name)), this.tsTypes = schema.reduce((acc, i) => (acc.set(i.name, this.getTypeNodeType(i)), acc), /* @__PURE__ */ new Map());
|
|
627
|
-
}
|
|
628
|
-
getTypeNames() {
|
|
629
|
-
return Array.from(this.tsTypes.keys());
|
|
630
|
-
}
|
|
631
|
-
getDocumentTypeNames() {
|
|
632
|
-
return Array.from(this.documentTypeNames);
|
|
633
|
-
}
|
|
634
|
-
getTsType(name) {
|
|
635
|
-
return this.tsTypes.get(name);
|
|
636
|
-
}
|
|
637
|
-
getIdentifier(name) {
|
|
638
|
-
return this.identifiers.get(name);
|
|
639
|
-
}
|
|
640
|
-
evaluateQuery(query) {
|
|
641
|
-
const ast = safeParseQuery(query), typeNode = groqJs.typeEvaluate(ast, this.schema), tsType = this.getTypeNodeType(typeNode), stats = SchemaTypeGenerator.calculateTypeStats(typeNode);
|
|
642
|
-
return { tsType, stats };
|
|
605
|
+
const queryReturnInterface = t__namespace.tsInterfaceDeclaration(
|
|
606
|
+
t__namespace.identifier("SanityQueries"),
|
|
607
|
+
null,
|
|
608
|
+
[],
|
|
609
|
+
t__namespace.tsInterfaceBody(
|
|
610
|
+
Object.entries(typesByQuerystring).map(([query, types]) => t__namespace.tsPropertySignature(
|
|
611
|
+
t__namespace.stringLiteral(query),
|
|
612
|
+
t__namespace.tsTypeAnnotation(
|
|
613
|
+
t__namespace.tsUnionType(types.map((type) => t__namespace.tsTypeReference(t__namespace.identifier(type))))
|
|
614
|
+
)
|
|
615
|
+
))
|
|
616
|
+
)
|
|
617
|
+
), declareModule = t__namespace.declareModule(
|
|
618
|
+
t__namespace.stringLiteral("@sanity/client"),
|
|
619
|
+
t__namespace.blockStatement([queryReturnInterface])
|
|
620
|
+
), clientImport = t__namespace.importDeclaration([], t__namespace.stringLiteral("@sanity/client"));
|
|
621
|
+
return new generator.CodeGenerator(t__namespace.program([clientImport, declareModule])).generate().code.trim();
|
|
643
622
|
}
|
|
644
|
-
|
|
645
|
-
|
|
646
|
-
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
}
|
|
654
|
-
|
|
655
|
-
const attributeValues = Object.values(typeNode.attributes), allAttributesNull = attributeValues.every((attr) => attr.value.type === "null"), hasMeaningfulRest = typeNode.rest && typeNode.rest.type !== "unknown";
|
|
656
|
-
if (attributeValues.length > 0 && allAttributesNull && !hasMeaningfulRest)
|
|
657
|
-
return null;
|
|
658
|
-
}
|
|
659
|
-
if (typeNode.type === "null")
|
|
660
|
-
return null;
|
|
661
|
-
const stats = SchemaTypeGenerator.calculateTypeStats(typeNode);
|
|
662
|
-
return { tsType: t__namespace.tsTypeReference(
|
|
663
|
-
t__namespace.identifier("DocumentTypeScoped"),
|
|
664
|
-
t__namespace.tsTypeParameterInstantiation([
|
|
665
|
-
this.getTypeNodeType(typeNode),
|
|
666
|
-
t__namespace.tsLiteralType(t__namespace.stringLiteral(typeName))
|
|
667
|
-
])
|
|
668
|
-
), stats };
|
|
669
|
-
}).filter((i) => !!i);
|
|
670
|
-
if (!results.length)
|
|
671
|
-
return {
|
|
672
|
-
tsType: t__namespace.tsNeverKeyword(),
|
|
673
|
-
// emptyUnions is 1 because the union type has no members, resulting in a `never` type
|
|
674
|
-
stats: { totalTypeNodes: 0, unknownTypeCount: 0, emptyUnionCount: 1 }
|
|
675
|
-
};
|
|
676
|
-
if (results.length === 1) return results[0];
|
|
677
|
-
const combinedTsType = t__namespace.tsUnionType(results.map((i) => i.tsType)), accumulatedStats = results.reduce(
|
|
678
|
-
(acc, { stats }) => ({
|
|
679
|
-
totalTypeNodes: acc.totalTypeNodes + stats.totalTypeNodes,
|
|
680
|
-
emptyUnionCount: acc.emptyUnionCount + stats.emptyUnionCount,
|
|
681
|
-
unknownTypeCount: acc.unknownTypeCount + stats.unknownTypeCount
|
|
682
|
-
}),
|
|
683
|
-
{ totalTypeNodes: 0, unknownTypeCount: 0, emptyUnionCount: 0 }
|
|
684
|
-
);
|
|
685
|
-
return accumulatedStats.totalTypeNodes += 1, { tsType: combinedTsType, stats: accumulatedStats };
|
|
623
|
+
/**
|
|
624
|
+
* Since we are sanitizing identifiers we migt end up with collisions. Ie there might be a type mux.video and muxVideo, both these
|
|
625
|
+
* types would be sanityized into MuxVideo. To avoid this we keep track of the generated type names and add a index to the name.
|
|
626
|
+
* When we reference a type we also keep track of the original name so we can reference the correct type later.
|
|
627
|
+
*/
|
|
628
|
+
getTypeName(name, typeNode) {
|
|
629
|
+
const desiredName = uppercaseFirstLetter(sanitizeIdentifier(name));
|
|
630
|
+
let generatedName = desiredName, i = 2;
|
|
631
|
+
for (; this.generatedTypeName.has(generatedName); )
|
|
632
|
+
generatedName = `${desiredName}_${i++}`;
|
|
633
|
+
return this.generatedTypeName.add(generatedName), this.typeNameMap.set(name, generatedName), typeNode && this.typeNodeNameMap.set(typeNode, generatedName), generatedName;
|
|
686
634
|
}
|
|
687
635
|
getTypeNodeType(typeNode) {
|
|
688
636
|
switch (typeNode.type) {
|
|
@@ -704,11 +652,8 @@ class SchemaTypeGenerator {
|
|
|
704
652
|
return this.generateObjectTsType(typeNode);
|
|
705
653
|
case "union":
|
|
706
654
|
return this.generateUnionTsType(typeNode);
|
|
707
|
-
case "inline":
|
|
708
|
-
|
|
709
|
-
if (!identifier) throw new Error(`Type "${typeNode.name}" not found in schema`);
|
|
710
|
-
return t__namespace.tsTypeReference(identifier);
|
|
711
|
-
}
|
|
655
|
+
case "inline":
|
|
656
|
+
return this.generateInlineTsType(typeNode);
|
|
712
657
|
case "null":
|
|
713
658
|
return t__namespace.tsNullKeyword();
|
|
714
659
|
default:
|
|
@@ -749,30 +694,38 @@ class SchemaTypeGenerator {
|
|
|
749
694
|
break;
|
|
750
695
|
}
|
|
751
696
|
case "inline": {
|
|
752
|
-
const
|
|
753
|
-
|
|
754
|
-
const missing = t__namespace.tsUnknownKeyword();
|
|
755
|
-
return missing.trailingComments = [
|
|
756
|
-
{
|
|
757
|
-
type: "CommentLine",
|
|
758
|
-
value: ` Unable to locate the referenced type "${rest.name}" in schema`
|
|
759
|
-
}
|
|
760
|
-
], missing;
|
|
761
|
-
}
|
|
762
|
-
return t__namespace.tsIntersectionType([t__namespace.tsTypeLiteral(props), t__namespace.tsTypeReference(identifier)]);
|
|
697
|
+
const resolved = this.generateInlineTsType(rest);
|
|
698
|
+
return t__namespace.isTSUnknownKeyword(resolved) ? resolved : t__namespace.tsIntersectionType([t__namespace.tsTypeLiteral(props), resolved]);
|
|
763
699
|
}
|
|
764
700
|
default:
|
|
765
701
|
throw new Error(`Type "${rest.type}" not found in schema`);
|
|
766
702
|
}
|
|
767
703
|
if (typeNode.dereferencesTo !== void 0) {
|
|
768
704
|
const derefType = t__namespace.tsPropertySignature(
|
|
769
|
-
t__namespace.identifier(
|
|
705
|
+
t__namespace.identifier(REFERENCE_SYMBOL_NAME),
|
|
770
706
|
t__namespace.tsTypeAnnotation(t__namespace.tsLiteralType(t__namespace.stringLiteral(typeNode.dereferencesTo)))
|
|
771
707
|
);
|
|
772
708
|
derefType.computed = !0, derefType.optional = !0, props.push(derefType);
|
|
773
709
|
}
|
|
774
710
|
return t__namespace.tsTypeLiteral(props);
|
|
775
711
|
}
|
|
712
|
+
generateInlineTsType(typeNode) {
|
|
713
|
+
const referencedTypeNode = this.schema.find((schema) => schema.name === typeNode.name);
|
|
714
|
+
if (referencedTypeNode === void 0) {
|
|
715
|
+
const generatedName2 = this.typeNameMap.get(typeNode.name);
|
|
716
|
+
if (generatedName2)
|
|
717
|
+
return t__namespace.tsTypeReference(t__namespace.identifier(generatedName2));
|
|
718
|
+
const missing = t__namespace.tsUnknownKeyword();
|
|
719
|
+
return missing.trailingComments = [
|
|
720
|
+
{
|
|
721
|
+
type: "CommentLine",
|
|
722
|
+
value: ` Unable to locate the referenced type "${typeNode.name}" in schema`
|
|
723
|
+
}
|
|
724
|
+
], missing;
|
|
725
|
+
}
|
|
726
|
+
const generatedName = this.typeNameMap.get(referencedTypeNode.name);
|
|
727
|
+
return generatedName ? t__namespace.tsTypeReference(t__namespace.identifier(generatedName)) : t__namespace.tsUnknownKeyword();
|
|
728
|
+
}
|
|
776
729
|
// Helper function used to generate TS types for union type nodes.
|
|
777
730
|
generateUnionTsType(typeNode) {
|
|
778
731
|
if (typeNode.of.length === 0)
|
|
@@ -789,310 +742,16 @@ class SchemaTypeGenerator {
|
|
|
789
742
|
);
|
|
790
743
|
return t__namespace.tsTypeLiteral(props);
|
|
791
744
|
}
|
|
792
|
-
// Helper function to calculate statistics for a TypeNode
|
|
793
|
-
static calculateTypeStats(typeNode) {
|
|
794
|
-
switch (typeNode.type) {
|
|
795
|
-
case "unknown":
|
|
796
|
-
return { totalTypeNodes: 1, unknownTypeCount: 1, emptyUnionCount: 0 };
|
|
797
|
-
case "array": {
|
|
798
|
-
const stats = SchemaTypeGenerator.calculateTypeStats(typeNode.of);
|
|
799
|
-
return stats.totalTypeNodes += 1, stats;
|
|
800
|
-
}
|
|
801
|
-
case "object": {
|
|
802
|
-
const initialStats = {
|
|
803
|
-
totalTypeNodes: 1,
|
|
804
|
-
unknownTypeCount: 0,
|
|
805
|
-
emptyUnionCount: 0
|
|
806
|
-
}, restStats = typeNode.rest ? SchemaTypeGenerator.calculateTypeStats(typeNode.rest) : null;
|
|
807
|
-
return restStats && (initialStats.totalTypeNodes += restStats.totalTypeNodes, initialStats.unknownTypeCount += restStats.unknownTypeCount, initialStats.emptyUnionCount += restStats.emptyUnionCount), Object.values(typeNode.attributes).reduce((acc, attribute) => {
|
|
808
|
-
const stats = SchemaTypeGenerator.calculateTypeStats(attribute.value);
|
|
809
|
-
return acc.totalTypeNodes += stats.totalTypeNodes, acc.unknownTypeCount += stats.unknownTypeCount, acc.emptyUnionCount += stats.emptyUnionCount, acc;
|
|
810
|
-
}, initialStats);
|
|
811
|
-
}
|
|
812
|
-
case "union":
|
|
813
|
-
return typeNode.of.length === 0 ? { totalTypeNodes: 1, unknownTypeCount: 0, emptyUnionCount: 1 } : typeNode.of.reduce(
|
|
814
|
-
(acc, type) => {
|
|
815
|
-
const stats = SchemaTypeGenerator.calculateTypeStats(type);
|
|
816
|
-
return acc.totalTypeNodes += stats.totalTypeNodes, acc.unknownTypeCount += stats.unknownTypeCount, acc.emptyUnionCount += stats.emptyUnionCount, acc;
|
|
817
|
-
},
|
|
818
|
-
{ totalTypeNodes: 1, unknownTypeCount: 0, emptyUnionCount: 0 }
|
|
819
|
-
// count the union type itself
|
|
820
|
-
);
|
|
821
|
-
case "type":
|
|
822
|
-
return SchemaTypeGenerator.calculateTypeStats(typeNode.value);
|
|
823
|
-
case "document": {
|
|
824
|
-
const initialStats = {
|
|
825
|
-
totalTypeNodes: 1,
|
|
826
|
-
unknownTypeCount: 0,
|
|
827
|
-
emptyUnionCount: 0
|
|
828
|
-
};
|
|
829
|
-
return Object.values(typeNode.attributes).reduce((acc, attribute) => {
|
|
830
|
-
const stats = SchemaTypeGenerator.calculateTypeStats(attribute.value);
|
|
831
|
-
return acc.totalTypeNodes += stats.totalTypeNodes, acc.unknownTypeCount += stats.unknownTypeCount, acc.emptyUnionCount += stats.emptyUnionCount, acc;
|
|
832
|
-
}, initialStats);
|
|
833
|
-
}
|
|
834
|
-
// Base types
|
|
835
|
-
case "string":
|
|
836
|
-
case "number":
|
|
837
|
-
case "boolean":
|
|
838
|
-
case "null":
|
|
839
|
-
case "inline":
|
|
840
|
-
default:
|
|
841
|
-
return { totalTypeNodes: 1, unknownTypeCount: 0, emptyUnionCount: 0 };
|
|
842
|
-
}
|
|
843
|
-
}
|
|
844
745
|
}
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
Object.assign(t__namespace.tsTypeOperator(t__namespace.tsSymbolKeyword()), { operator: "unique" })
|
|
848
|
-
)
|
|
849
|
-
});
|
|
850
|
-
function generateCode(node) {
|
|
851
|
-
return `${new generator.CodeGenerator(node).generate().code.trim()}
|
|
852
|
-
|
|
853
|
-
`;
|
|
854
|
-
}
|
|
855
|
-
function scopeByDataset(tsType, options) {
|
|
856
|
-
return t__namespace.tsTypeReference(
|
|
857
|
-
DatasetScoped,
|
|
858
|
-
t__namespace.tsTypeParameterInstantiation([
|
|
859
|
-
tsType,
|
|
860
|
-
t__namespace.tsLiteralType(t__namespace.stringLiteral(options.dataset)),
|
|
861
|
-
t__namespace.tsLiteralType(t__namespace.stringLiteral(options.projectId))
|
|
862
|
-
])
|
|
863
|
-
);
|
|
864
|
-
}
|
|
865
|
-
function PromiseWithResolvers() {
|
|
866
|
-
let resolve, reject;
|
|
867
|
-
return { promise: new Promise((thisResolve, thisReject) => {
|
|
868
|
-
resolve = thisResolve, reject = thisReject;
|
|
869
|
-
}), resolve, reject };
|
|
870
|
-
}
|
|
871
|
-
function generateTypes({
|
|
872
|
-
schemas,
|
|
873
|
-
queriesByFile,
|
|
874
|
-
augmentGroqModule,
|
|
875
|
-
overloadClientMethods
|
|
876
|
-
}) {
|
|
877
|
-
const globalIdentifiers = /* @__PURE__ */ new Set();
|
|
878
|
-
globalIdentifiers.add(SanityQueries.name), globalIdentifiers.add(SanityProjections.name), globalIdentifiers.add(SanitySchemas.name), globalIdentifiers.add(DocumentTypeScoped.name), globalIdentifiers.add(DatasetScoped.name), globalIdentifiers.add(ExtractDataset.name), globalIdentifiers.add(AllSchemaTypes.name), globalIdentifiers.add(ReferenceSymbol.name);
|
|
879
|
-
const generatedQueries = new AsyncQueue(), {
|
|
880
|
-
promise: generatedSchema,
|
|
881
|
-
resolve: resolveGeneratedSchema,
|
|
882
|
-
reject: rejectGeneratedSchema
|
|
883
|
-
} = PromiseWithResolvers(), {
|
|
884
|
-
promise: generatedTypemap,
|
|
885
|
-
resolve: resolveGeneratedTypemap,
|
|
886
|
-
reject: rejectGeneratedTypemap
|
|
887
|
-
} = PromiseWithResolvers();
|
|
888
|
-
return (async () => {
|
|
889
|
-
const schemaGenerators = schemas.map((options) => new SchemaTypeGenerator(options)), typeNames = new Set(schemaGenerators.flatMap((i) => i.getTypeNames()));
|
|
890
|
-
let schemaCode = "";
|
|
891
|
-
overloadClientMethods && (schemaCode += generateCode(t__namespace.importDeclaration([], t__namespace.stringLiteral("@sanity/client")))), schemaCode += generateCode(
|
|
892
|
-
Object.assign(
|
|
893
|
-
t__namespace.importDeclaration(
|
|
894
|
-
[
|
|
895
|
-
t__namespace.importSpecifier(DocumentTypeScoped, DocumentTypeScoped),
|
|
896
|
-
t__namespace.importSpecifier(ExtractDataset, ExtractDataset),
|
|
897
|
-
t__namespace.importSpecifier(DatasetScoped, DatasetScoped)
|
|
898
|
-
],
|
|
899
|
-
t__namespace.stringLiteral("groq")
|
|
900
|
-
),
|
|
901
|
-
{ importKind: "type" }
|
|
902
|
-
)
|
|
903
|
-
), schemaCode += generateCode(
|
|
904
|
-
t__namespace.exportNamedDeclaration(
|
|
905
|
-
Object.assign(t__namespace.variableDeclaration("const", [t__namespace.variableDeclarator(ReferenceSymbol)]), {
|
|
906
|
-
declare: !0
|
|
907
|
-
})
|
|
908
|
-
)
|
|
909
|
-
);
|
|
910
|
-
const schemaIdentifiers = /* @__PURE__ */ new Set();
|
|
911
|
-
for (const typeName of typeNames) {
|
|
912
|
-
const identifiers = new Set(
|
|
913
|
-
schemaGenerators.map((i) => i.getIdentifier(typeName)?.name).filter((i) => typeof i == "string")
|
|
914
|
-
);
|
|
915
|
-
for (const identifier of identifiers) {
|
|
916
|
-
globalIdentifiers.add(identifier);
|
|
917
|
-
const tsTypes = schemaGenerators.filter((i) => i.getIdentifier(typeName)?.name === identifier).map((i) => {
|
|
918
|
-
const tsType2 = i.getTsType(typeName);
|
|
919
|
-
return tsType2 && schemaGenerators.length > 1 ? scopeByDataset(tsType2, i) : tsType2;
|
|
920
|
-
}).filter((i) => i !== void 0), tsType = tsTypes.length === 1 ? tsTypes[0] : t__namespace.tsUnionType(tsTypes), typeAlias = t__namespace.tsTypeAliasDeclaration(t__namespace.identifier(identifier), null, tsType), code = generateCode(t__namespace.exportNamedDeclaration(typeAlias));
|
|
921
|
-
schemaIdentifiers.add(identifier), schemaCode += code;
|
|
922
|
-
}
|
|
923
|
-
}
|
|
924
|
-
const allSchemaTypesDeclaration = generateCode(
|
|
925
|
-
t__namespace.exportNamedDeclaration(
|
|
926
|
-
t__namespace.tsTypeAliasDeclaration(
|
|
927
|
-
AllSchemaTypes,
|
|
928
|
-
null,
|
|
929
|
-
t__namespace.tsUnionType(
|
|
930
|
-
Array.from(schemaIdentifiers).map(
|
|
931
|
-
(identifier) => t__namespace.tsTypeReference(t__namespace.identifier(identifier))
|
|
932
|
-
)
|
|
933
|
-
)
|
|
934
|
-
)
|
|
935
|
-
)
|
|
936
|
-
);
|
|
937
|
-
if (schemaCode += allSchemaTypesDeclaration, augmentGroqModule) {
|
|
938
|
-
const sanitySchemasProperties = schemas.map(
|
|
939
|
-
({ dataset, projectId }) => t__namespace.tsPropertySignature(
|
|
940
|
-
t__namespace.stringLiteral(`${projectId}:${dataset}`),
|
|
941
|
-
t__namespace.tsTypeAnnotation(
|
|
942
|
-
t__namespace.tsTypeReference(
|
|
943
|
-
ExtractDataset,
|
|
944
|
-
t__namespace.tsTypeParameterInstantiation([
|
|
945
|
-
t__namespace.tsTypeReference(AllSchemaTypes),
|
|
946
|
-
t__namespace.tsLiteralType(t__namespace.stringLiteral(dataset)),
|
|
947
|
-
t__namespace.tsLiteralType(t__namespace.stringLiteral(projectId))
|
|
948
|
-
])
|
|
949
|
-
)
|
|
950
|
-
)
|
|
951
|
-
)
|
|
952
|
-
), sanitySchemasDeclaration = generateCode(
|
|
953
|
-
t__namespace.declareModule(
|
|
954
|
-
t__namespace.stringLiteral("groq"),
|
|
955
|
-
t__namespace.blockStatement([
|
|
956
|
-
t__namespace.tsInterfaceDeclaration(
|
|
957
|
-
SanitySchemas,
|
|
958
|
-
null,
|
|
959
|
-
[],
|
|
960
|
-
t__namespace.tsInterfaceBody(sanitySchemasProperties)
|
|
961
|
-
)
|
|
962
|
-
])
|
|
963
|
-
)
|
|
964
|
-
);
|
|
965
|
-
schemaCode += sanitySchemasDeclaration;
|
|
966
|
-
}
|
|
967
|
-
resolveGeneratedSchema({
|
|
968
|
-
code: schemaCode,
|
|
969
|
-
schemas: schemas.map(({ schema, ...rest }) => ({
|
|
970
|
-
...rest,
|
|
971
|
-
typeCount: schema.length
|
|
972
|
-
}))
|
|
973
|
-
});
|
|
974
|
-
const queryIdentifiers = /* @__PURE__ */ new Map(), projectionIdentifiers = /* @__PURE__ */ new Map(), totalStats = {
|
|
975
|
-
totalTypeNodes: 0,
|
|
976
|
-
unknownTypeCount: 0,
|
|
977
|
-
emptyUnionCount: 0
|
|
978
|
-
};
|
|
979
|
-
for await (const input of queriesByFile)
|
|
980
|
-
try {
|
|
981
|
-
if (input.type === "error") throw input.error;
|
|
982
|
-
const results = [];
|
|
983
|
-
for (const query of input.queries) {
|
|
984
|
-
const desiredName = SchemaTypeGenerator.sanitizeIdentifier(
|
|
985
|
-
query.type === "projection" ? `${query.name}ProjectionResult` : `${query.name}Result`
|
|
986
|
-
);
|
|
987
|
-
let resultingName = desiredName, index = 2;
|
|
988
|
-
for (; globalIdentifiers.has(resultingName); )
|
|
989
|
-
resultingName = `${desiredName}_${index}`, index++;
|
|
990
|
-
const identifier = t__namespace.identifier(resultingName);
|
|
991
|
-
let identifiers = query.type === "projection" ? projectionIdentifiers.get(query.result) : queryIdentifiers.get(query.result);
|
|
992
|
-
identifiers || (identifiers = [], query.type === "projection" ? projectionIdentifiers.set(query.result, identifiers) : queryIdentifiers.set(query.result, identifiers)), identifiers.push(identifier);
|
|
993
|
-
const evaluationResults = schemaGenerators.map((i) => query.type === "projection" ? i.evaluateProjection(query.result) : i.evaluateQuery(query.result)), aggregatedQueryStats = evaluationResults.reduce(
|
|
994
|
-
(acc, { stats }) => ({
|
|
995
|
-
totalTypeNodes: acc.totalTypeNodes + stats.totalTypeNodes,
|
|
996
|
-
unknownTypeCount: acc.unknownTypeCount + stats.unknownTypeCount,
|
|
997
|
-
emptyUnionCount: acc.emptyUnionCount + stats.emptyUnionCount
|
|
998
|
-
}),
|
|
999
|
-
{ totalTypeNodes: 0, unknownTypeCount: 0, emptyUnionCount: 0 }
|
|
1000
|
-
);
|
|
1001
|
-
totalStats.totalTypeNodes += aggregatedQueryStats.totalTypeNodes, totalStats.unknownTypeCount += aggregatedQueryStats.unknownTypeCount, totalStats.emptyUnionCount += aggregatedQueryStats.emptyUnionCount;
|
|
1002
|
-
const tsTypes = evaluationResults.map(({ tsType: tsType2 }, resultIndex) => schemas.length === 1 ? tsType2 : scopeByDataset(tsType2, schemaGenerators[resultIndex])), tsType = tsTypes.length === 1 ? tsTypes[0] : t__namespace.tsUnionType(tsTypes), typeAlias = t__namespace.tsTypeAliasDeclaration(identifier, null, tsType), code = generateCode(
|
|
1003
|
-
t__namespace.addComments(t__namespace.exportNamedDeclaration(typeAlias), "leading", [
|
|
1004
|
-
{ type: "CommentLine", value: ` Source: ${input.filename}` },
|
|
1005
|
-
{ type: "CommentLine", value: ` Variable: ${query.name}` },
|
|
1006
|
-
{
|
|
1007
|
-
type: "CommentLine",
|
|
1008
|
-
value: ` ${query.type === "projection" ? "Projection" : "Query"}: ${query.result.replace(/(\r\n|\n|\r)/gm, "").trim()}`
|
|
1009
|
-
}
|
|
1010
|
-
])
|
|
1011
|
-
);
|
|
1012
|
-
results.push({
|
|
1013
|
-
name: query.name,
|
|
1014
|
-
query: query.result,
|
|
1015
|
-
type: query.type,
|
|
1016
|
-
code,
|
|
1017
|
-
stats: aggregatedQueryStats
|
|
1018
|
-
});
|
|
1019
|
-
}
|
|
1020
|
-
generatedQueries.enqueue({ filename: input.filename, results });
|
|
1021
|
-
} catch (error) {
|
|
1022
|
-
generatedQueries.enqueue({ filename: input.filename, results: [], error });
|
|
1023
|
-
}
|
|
1024
|
-
generatedQueries.finish();
|
|
1025
|
-
let typemapCode = "";
|
|
1026
|
-
const clientModuleBlockStatement = [], groqModuleBlockStatement = [];
|
|
1027
|
-
if (queryIdentifiers.size > 0) {
|
|
1028
|
-
const sanityQueriesInterfaceDeclaration = t__namespace.tsInterfaceDeclaration(
|
|
1029
|
-
SanityQueries,
|
|
1030
|
-
null,
|
|
1031
|
-
[],
|
|
1032
|
-
t__namespace.tsInterfaceBody(
|
|
1033
|
-
Array.from(queryIdentifiers).map(
|
|
1034
|
-
([query, identifiers]) => t__namespace.tsPropertySignature(
|
|
1035
|
-
t__namespace.stringLiteral(query),
|
|
1036
|
-
t__namespace.tsTypeAnnotation(
|
|
1037
|
-
identifiers.length === 1 ? t__namespace.tsTypeReference(identifiers[0]) : t__namespace.tsUnionType(identifiers.map((i) => t__namespace.tsTypeReference(i)))
|
|
1038
|
-
)
|
|
1039
|
-
)
|
|
1040
|
-
)
|
|
1041
|
-
)
|
|
1042
|
-
);
|
|
1043
|
-
clientModuleBlockStatement.push(sanityQueriesInterfaceDeclaration), groqModuleBlockStatement.push(sanityQueriesInterfaceDeclaration);
|
|
1044
|
-
}
|
|
1045
|
-
if (projectionIdentifiers.size > 0) {
|
|
1046
|
-
const sanityProjectionsInterfaceDeclaration = t__namespace.tsInterfaceDeclaration(
|
|
1047
|
-
SanityProjections,
|
|
1048
|
-
null,
|
|
1049
|
-
[],
|
|
1050
|
-
t__namespace.tsInterfaceBody(
|
|
1051
|
-
Array.from(projectionIdentifiers).map(
|
|
1052
|
-
([projection, identifiers]) => t__namespace.tsPropertySignature(
|
|
1053
|
-
t__namespace.stringLiteral(projection),
|
|
1054
|
-
t__namespace.tsTypeAnnotation(
|
|
1055
|
-
identifiers.length === 1 ? t__namespace.tsTypeReference(identifiers[0]) : t__namespace.tsUnionType(identifiers.map((i) => t__namespace.tsTypeReference(i)))
|
|
1056
|
-
)
|
|
1057
|
-
)
|
|
1058
|
-
)
|
|
1059
|
-
)
|
|
1060
|
-
);
|
|
1061
|
-
groqModuleBlockStatement.push(sanityProjectionsInterfaceDeclaration);
|
|
1062
|
-
}
|
|
1063
|
-
if (overloadClientMethods && clientModuleBlockStatement.length > 0) {
|
|
1064
|
-
const clientModuleDeclaration = t__namespace.declareModule(
|
|
1065
|
-
t__namespace.stringLiteral("@sanity/client"),
|
|
1066
|
-
t__namespace.blockStatement(clientModuleBlockStatement)
|
|
1067
|
-
);
|
|
1068
|
-
typemapCode += generateCode(clientModuleDeclaration);
|
|
1069
|
-
}
|
|
1070
|
-
if (augmentGroqModule && groqModuleBlockStatement.length > 0) {
|
|
1071
|
-
const groqModuleDeclaration = t__namespace.declareModule(
|
|
1072
|
-
t__namespace.stringLiteral("groq"),
|
|
1073
|
-
t__namespace.blockStatement(groqModuleBlockStatement)
|
|
1074
|
-
);
|
|
1075
|
-
typemapCode += generateCode(groqModuleDeclaration);
|
|
1076
|
-
}
|
|
1077
|
-
resolveGeneratedTypemap({
|
|
1078
|
-
code: typemapCode,
|
|
1079
|
-
stats: totalStats
|
|
1080
|
-
});
|
|
1081
|
-
})().catch((err) => {
|
|
1082
|
-
generatedQueries.throwError(err), rejectGeneratedSchema(err), rejectGeneratedTypemap(err);
|
|
1083
|
-
}), {
|
|
1084
|
-
generatedSchema: () => generatedSchema,
|
|
1085
|
-
generatedQueries: () => generatedQueries,
|
|
1086
|
-
generatedTypemap: () => generatedTypemap
|
|
1087
|
-
};
|
|
746
|
+
function uppercaseFirstLetter(input) {
|
|
747
|
+
return input.charAt(0).toUpperCase() + input.slice(1);
|
|
1088
748
|
}
|
|
1089
|
-
function
|
|
1090
|
-
|
|
1091
|
-
register__default.default({ ...options, extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] });
|
|
749
|
+
function sanitizeIdentifier(input) {
|
|
750
|
+
return `${input.replace(/^\d/, "_").replace(/[^$\w]+(.)/g, (_, char) => char.toUpperCase())}`;
|
|
1092
751
|
}
|
|
752
|
+
exports.TypeGenerator = TypeGenerator;
|
|
1093
753
|
exports.findQueriesInPath = findQueriesInPath;
|
|
1094
754
|
exports.findQueriesInSource = findQueriesInSource;
|
|
1095
|
-
exports.generateTypes = generateTypes;
|
|
1096
755
|
exports.getResolver = getResolver;
|
|
1097
756
|
exports.readConfig = readConfig;
|
|
1098
757
|
exports.readSchema = readSchema;
|