@soda-gql/core 0.0.9 → 0.2.0

package/dist/runtime.js

@@ -0,0 +1,82 @@
+//#region packages/core/src/utils/hidden.ts
+const _dummy = () => {
+	throw new Error("DO NOT CALL THIS FUNCTION -- we use function to safely transfer type information");
+};
+const hidden = () => _dummy;
+
+//#endregion
+//#region packages/core/src/runtime/fragment.ts
+const createRuntimeFragment = (input) => {
+	const fragment = {
+		typename: input.prebuild.typename,
+		embed: hidden(),
+		attach(attachment) {
+			const value = attachment.createValue(fragment);
+			Object.defineProperty(fragment, attachment.name, { get() {
+				return value;
+			} });
+			return fragment;
+		}
+	};
+	return fragment;
+};
+
+//#endregion
+//#region packages/core/src/runtime/runtime-registry.ts
+const operationRegistry = /* @__PURE__ */ new Map();
+const registerOperation = (operation) => {
+	operationRegistry.set(operation.operationName, operation);
+};
+const getOperation = (name) => {
+	const operation = operationRegistry.get(name);
+	if (!operation) throw new Error(`Operation ${name} not found`);
+	return operation;
+};
+/**
+* Test-only function to reset the operation registry
+* @internal
+*/
+const __resetRuntimeRegistry = () => {
+	operationRegistry.clear();
+};
+/**
+* Test-only function to get all registered operations
+* @internal
+*/
+const __getRegisteredOperations = () => {
+	return operationRegistry;
+};
+
+//#endregion
+//#region packages/core/src/runtime/operation.ts
+const createRuntimeOperation = (input) => {
+	const operation = {
+		operationType: input.prebuild.operationType,
+		operationName: input.prebuild.operationName,
+		variableNames: input.prebuild.variableNames,
+		documentSource: hidden(),
+		document: input.prebuild.document,
+		metadata: input.prebuild.metadata,
+		attach(attachment) {
+			const value = attachment.createValue(operation);
+			Object.defineProperty(operation, attachment.name, { get() {
+				return value;
+			} });
+			return operation;
+		}
+	};
+	registerOperation(operation);
+	return operation;
+};
+
+//#endregion
+//#region packages/core/src/runtime/index.ts
+const gqlRuntime = {
+	fragment: createRuntimeFragment,
+	operation: createRuntimeOperation,
+	getOperation
+};
+
+//#endregion
+export { __getRegisteredOperations, __resetRuntimeRegistry, gqlRuntime };
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","names":[],"sources":["../src/utils/hidden.ts","../src/runtime/fragment.ts","../src/runtime/runtime-registry.ts","../src/runtime/operation.ts","../src/runtime/index.ts"],"sourcesContent":["const _dummy = () => {\n  throw new Error(\"DO NOT CALL THIS FUNCTION -- we use function to safely transfer type information\");\n};\nexport const hidden = <T>(): (() => T) => _dummy;\nexport type Hidden<T> = () => T;\n","import type { AnyFragment, GqlElementAttachment } from \"../types/element\";\nimport { hidden } from \"../utils/hidden\";\nimport type { StripFunctions, StripSymbols } from \"../utils/type-utils\";\n\nexport type RuntimeFragmentInput = {\n  prebuild: StripFunctions<AnyFragment>;\n};\n\nexport const createRuntimeFragment = (input: RuntimeFragmentInput): AnyFragment => {\n  const fragment = {\n    typename: input.prebuild.typename,\n    embed: hidden(),\n    attach<TName extends string, TValue extends object>(attachment: GqlElementAttachment<typeof fragment, TName, TValue>) {\n      const value = attachment.createValue(fragment);\n\n      Object.defineProperty(fragment, attachment.name, {\n        get() {\n          return value;\n        },\n      });\n\n      return fragment as typeof fragment & { [_ in TName]: TValue };\n    },\n  } satisfies StripSymbols<AnyFragment> as unknown as AnyFragment;\n\n  return fragment;\n};\n","import type { AnyOperationOf } from \"../types/element\";\nimport type { OperationType } from \"../types/schema\";\n\nconst operationRegistry = new Map<string, AnyOperationOf<OperationType>>();\n\nexport const registerOperation = (operation: AnyOperationOf<OperationType>) => {\n  operationRegistry.set(operation.operationName, operation);\n};\n\nexport const getOperation = (name: string) => {\n  const operation = operationRegistry.get(name);\n  if (!operation) {\n    throw new Error(`Operation ${name} not found`);\n  }\n  return operation;\n};\n\n/**\n * Test-only function to reset the operation registry\n * @internal\n */\nexport const __resetRuntimeRegistry = () => {\n  operationRegistry.clear();\n};\n\n/**\n * Test-only function to get all registered operations\n * @internal\n */\nexport const __getRegisteredOperations = (): ReadonlyMap<string, AnyOperationOf<OperationType>> => {\n  return operationRegistry;\n};\n","import type { AnyOperationOf, GqlElementAttachment } from \"../types/element\";\nimport type { OperationType } from \"../types/schema\";\nimport { hidden } from \"../utils/hidden\";\nimport type { StripFunctions, StripSymbols } from \"../utils/type-utils\";\nimport { registerOperation } from \"./runtime-registry\";\n\nexport type RuntimeOperationInput = {\n  prebuild: StripFunctions<AnyOperationOf<OperationType>>;\n  /**\n   * Reserved for future runtime configuration injection.\n   * Currently always an empty object, but kept for forward compatibility\n   * with potential features like runtime variable injection or context.\n   */\n  runtime: {};\n};\n\nexport const createRuntimeOperation = (input: RuntimeOperationInput): AnyOperationOf<OperationType> => {\n  const operation = {\n    operationType: input.prebuild.operationType,\n    operationName: input.prebuild.operationName,\n    variableNames: input.prebuild.variableNames,\n    documentSource: hidden(),\n    document: input.prebuild.document,\n    metadata: input.prebuild.metadata,\n    attach<TName extends string, TValue extends object>(attachment: GqlElementAttachment<typeof operation, TName, TValue>) {\n      const value = attachment.createValue(operation);\n\n      Object.defineProperty(operation, attachment.name, {\n        get() {\n          return value;\n        },\n      });\n\n      return operation as typeof operation & { [_ in TName]: TValue };\n    },\n  } satisfies StripSymbols<AnyOperationOf<OperationType>> as AnyOperationOf<OperationType>;\n\n  registerOperation(operation);\n\n  return operation;\n};\n","import { createRuntimeFragment } from \"./fragment\";\nimport { createRuntimeOperation } from \"./operation\";\nimport { getOperation } from \"./runtime-registry\";\n\nexport type { RuntimeFragmentInput } from \"./fragment\";\nexport type { RuntimeOperationInput } from \"./operation\";\nexport { __getRegisteredOperations, __resetRuntimeRegistry } from \"./runtime-registry\";\n\nexport const gqlRuntime = {\n  fragment: createRuntimeFragment,\n  operation: createRuntimeOperation,\n  getOperation,\n};\n"],"mappings":";AAAA,MAAM,eAAe;AACnB,OAAM,IAAI,MAAM,mFAAmF;;AAErG,MAAa,eAA6B;;;;ACK1C,MAAa,yBAAyB,UAA6C;CACjF,MAAM,WAAW;EACf,UAAU,MAAM,SAAS;EACzB,OAAO,QAAQ;EACf,OAAoD,YAAkE;GACpH,MAAM,QAAQ,WAAW,YAAY,SAAS;AAE9C,UAAO,eAAe,UAAU,WAAW,MAAM,EAC/C,MAAM;AACJ,WAAO;MAEV,CAAC;AAEF,UAAO;;EAEV;AAED,QAAO;;;;;ACtBT,MAAM,oCAAoB,IAAI,KAA4C;AAE1E,MAAa,qBAAqB,cAA6C;AAC7E,mBAAkB,IAAI,UAAU,eAAe,UAAU;;AAG3D,MAAa,gBAAgB,SAAiB;CAC5C,MAAM,YAAY,kBAAkB,IAAI,KAAK;AAC7C,KAAI,CAAC,UACH,OAAM,IAAI,MAAM,aAAa,KAAK,YAAY;AAEhD,QAAO;;;;;;AAOT,MAAa,+BAA+B;AAC1C,mBAAkB,OAAO;;;;;;AAO3B,MAAa,kCAAsF;AACjG,QAAO;;;;;ACdT,MAAa,0BAA0B,UAAgE;CACrG,MAAM,YAAY;EAChB,eAAe,MAAM,SAAS;EAC9B,eAAe,MAAM,SAAS;EAC9B,eAAe,MAAM,SAAS;EAC9B,gBAAgB,QAAQ;EACxB,UAAU,MAAM,SAAS;EACzB,UAAU,MAAM,SAAS;EACzB,OAAoD,YAAmE;GACrH,MAAM,QAAQ,WAAW,YAAY,UAAU;AAE/C,UAAO,eAAe,WAAW,WAAW,MAAM,EAChD,MAAM;AACJ,WAAO;MAEV,CAAC;AAEF,UAAO;;EAEV;AAED,mBAAkB,UAAU;AAE5B,QAAO;;;;;AC/BT,MAAa,aAAa;CACxB,UAAU;CACV,WAAW;CACX;CACD"}

package/dist/schema-Bip7o0g3.cjs

@@ -0,0 +1,128 @@
+
+//#region packages/core/src/utils/type-meta.ts
+const withTypeMeta = (target) => {
+	if (process.env.NODE_ENV !== "production") {
+		if (typeof target !== "object" && typeof target !== "function" || target === null) throw new Error("Target must be an object or a function.");
+		Object.defineProperty(target, "$type", { get() {
+			throw new Error("This property is only for type inference. Do not access this property directly.");
+		} });
+	}
+	return target;
+};
+
+//#endregion
+//#region packages/core/src/utils/wrap-by-key.ts
+function wrapByKey(name, value) {
+	return { [name]: value };
+}
+
+//#endregion
+//#region packages/core/src/types/type-foundation/modified-type-name.ts
+function parseModifiedTypeName(nameAndModifier) {
+	if (typeof nameAndModifier !== "string") throw new Error(`Invalid modified type name: ${nameAndModifier}`);
+	const [name, modifier] = nameAndModifier.split(":");
+	return {
+		name,
+		modifier
+	};
+}
+
+//#endregion
+//#region packages/core/src/schema/type-specifier-builder.ts
+const createUnsafeInputTypeSpecifierFactory = (kind) => {
+	return (type, extras) => ({
+		kind,
+		...parseModifiedTypeName(type),
+		defaultValue: extras.default ? { default: extras.default() } : null
+	});
+};
+const unsafeInputType = {
+	scalar: createUnsafeInputTypeSpecifierFactory("scalar"),
+	enum: createUnsafeInputTypeSpecifierFactory("enum"),
+	input: createUnsafeInputTypeSpecifierFactory("input")
+};
+const createUnsafeOutputTypeSpecifierFactory = (kind) => {
+	return (type, extras) => ({
+		kind,
+		...parseModifiedTypeName(type),
+		arguments: extras.arguments ?? {}
+	});
+};
+const unsafeOutputType = {
+	scalar: createUnsafeOutputTypeSpecifierFactory("scalar"),
+	enum: createUnsafeOutputTypeSpecifierFactory("enum"),
+	object: createUnsafeOutputTypeSpecifierFactory("object"),
+	union: createUnsafeOutputTypeSpecifierFactory("union"),
+	typename: createUnsafeOutputTypeSpecifierFactory("typename")
+};
+
+//#endregion
+//#region packages/core/src/schema/schema-builder.ts
+const defineScalar = (name) => wrapByKey(name, withTypeMeta({ name }));
+const define = (name) => ({
+	enum: (values) => withTypeMeta({
+		name,
+		values
+	}),
+	input: (fields) => ({
+		name,
+		fields
+	}),
+	object: (fields) => ({
+		name,
+		fields: {
+			__typename: unsafeOutputType.typename(`${name}:!`, {}),
+			...fields
+		}
+	}),
+	union: (types) => ({
+		name,
+		types
+	})
+});
+const defineOperationRoots = (operationRoots) => operationRoots;
+
+//#endregion
+Object.defineProperty(exports, 'define', {
+  enumerable: true,
+  get: function () {
+    return define;
+  }
+});
+Object.defineProperty(exports, 'defineOperationRoots', {
+  enumerable: true,
+  get: function () {
+    return defineOperationRoots;
+  }
+});
+Object.defineProperty(exports, 'defineScalar', {
+  enumerable: true,
+  get: function () {
+    return defineScalar;
+  }
+});
+Object.defineProperty(exports, 'parseModifiedTypeName', {
+  enumerable: true,
+  get: function () {
+    return parseModifiedTypeName;
+  }
+});
+Object.defineProperty(exports, 'unsafeInputType', {
+  enumerable: true,
+  get: function () {
+    return unsafeInputType;
+  }
+});
+Object.defineProperty(exports, 'unsafeOutputType', {
+  enumerable: true,
+  get: function () {
+    return unsafeOutputType;
+  }
+});
+Object.defineProperty(exports, 'wrapByKey', {
+  enumerable: true,
+  get: function () {
+    return wrapByKey;
+  }
+});
+//# sourceMappingURL=schema-Bip7o0g3.cjs.map

package/dist/schema-Bip7o0g3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-Bip7o0g3.cjs","names":[],"sources":["../src/utils/type-meta.ts","../src/utils/wrap-by-key.ts","../src/types/type-foundation/modified-type-name.ts","../src/schema/type-specifier-builder.ts","../src/schema/schema-builder.ts"],"sourcesContent":["export interface WithTypeMeta<T extends object> {\n  readonly $type: T;\n}\n\nexport const withTypeMeta = <TTarget extends WithTypeMeta<TTypeMeta>, TTypeMeta extends object>(\n  target: Omit<NoInfer<TTarget>, \"$type\">,\n): TTarget => {\n  if (process.env.NODE_ENV !== \"production\") {\n    if ((typeof target !== \"object\" && typeof target !== \"function\") || target === null) {\n      throw new Error(\"Target must be an object or a function.\");\n    }\n\n    Object.defineProperty(target, \"$type\", {\n      get() {\n        throw new Error(\"This property is only for type inference. Do not access this property directly.\");\n      },\n    });\n  }\n\n  return target as TTarget;\n};\n","export function wrapByKey<TName extends string, TValue>(name: TName, value: TValue) {\n  return {\n    [name]: value,\n  } as {\n    [K in TName]: TValue;\n  };\n}\n","import type { TypeModifier, ValidTypeModifier } from \"./type-modifier-core.generated\";\n\nexport type ModifiedTypeName<\n  // Wrapping by array to avoid type distribution\n  TNameCandidate extends [string],\n  TName extends TNameCandidate[0],\n  TModifier extends TypeModifier,\n> = [string] extends TNameCandidate // For abstract implementation\n  ? `${TName}:${TModifier}`\n  : TNameCandidate extends [TName]\n    ? // First, user inputs TName based on TNameCandidate\n      NoInfer<`${TNameCandidate[0]}`> | (TName & NoInfer<TypeModifier extends TModifier ? never : string>)\n    : // With valid TName, user can input TModifier based on TypeModifierNS.ValidTypeModifier\n      `${TName}:${TModifier & ValidTypeModifier}`;\n\nexport function parseModifiedTypeName<TNameCandidate extends [string], TName extends string, TModifier extends TypeModifier>(\n  nameAndModifier: ModifiedTypeName<TNameCandidate, TName, TModifier>,\n) {\n  if (typeof nameAndModifier !== \"string\") {\n    throw new Error(`Invalid modified type name: ${nameAndModifier}`);\n  }\n\n  const [name, modifier] = nameAndModifier.split(\":\") as [TName, TModifier];\n  return { name, modifier };\n}\n","import type { AnyConstDirectiveAttachments } from \"../types/schema\";\nimport {\n  type AnyTypeSpecifier,\n  type InputTypeKind,\n  type InputTypeSpecifiers,\n  type ModifiedTypeName,\n  type OutputTypeKind,\n  parseModifiedTypeName,\n  type TypeModifier,\n} from \"../types/type-foundation\";\nimport type { ConstValue } from \"../types/type-foundation/const-value\";\n\nconst createUnsafeInputTypeSpecifierFactory = <const TKind extends InputTypeKind>(kind: TKind) => {\n  type UnsafeInputTypeSpecifier<\n    TName extends string,\n    TModifier extends TypeModifier,\n    TDefaultFactory extends (() => ConstValue) | null,\n    TDirectives extends AnyConstDirectiveAttachments,\n  > = {\n    kind: TKind;\n    name: TName;\n    modifier: TModifier;\n    defaultValue: TDefaultFactory extends null ? null : { default: ReturnType<NonNullable<TDefaultFactory>> };\n    directives: TDirectives;\n  };\n\n  return <\n    const TName extends string,\n    const TModifier extends TypeModifier,\n    const TDefaultFactory extends (() => ConstValue) | null = null,\n    const TDirectives extends AnyConstDirectiveAttachments = {},\n  >(\n    type: ModifiedTypeName<[string], TName, TModifier>,\n    extras: {\n      default?: TDefaultFactory;\n      directives?: TDirectives;\n    },\n  ): UnsafeInputTypeSpecifier<TName, TModifier, TDefaultFactory, TDirectives> =>\n    ({\n      kind,\n      ...parseModifiedTypeName(type),\n      defaultValue: extras.default ? { default: extras.default() } : null,\n    }) satisfies AnyTypeSpecifier as UnsafeInputTypeSpecifier<TName, TModifier, TDefaultFactory, TDirectives>;\n};\n\nexport const unsafeInputType = {\n  scalar: createUnsafeInputTypeSpecifierFactory(\"scalar\"),\n  enum: createUnsafeInputTypeSpecifierFactory(\"enum\"),\n  input: createUnsafeInputTypeSpecifierFactory(\"input\"),\n};\n\nconst createUnsafeOutputTypeSpecifierFactory = <const TKind extends OutputTypeKind>(kind: TKind) => {\n  type UnsafeOutputTypeSpecifier<TName extends string, TModifier extends TypeModifier, TArguments extends InputTypeSpecifiers> = {\n    kind: TKind;\n    name: TName;\n    modifier: TModifier;\n    arguments: TArguments;\n  };\n\n  return <const TName extends string, const TModifier extends TypeModifier, const TArguments extends InputTypeSpecifiers = {}>(\n    type: ModifiedTypeName<[string], TName, TModifier>,\n    extras: {\n      arguments?: TArguments;\n    },\n  ): UnsafeOutputTypeSpecifier<TName, TModifier, InputTypeSpecifiers extends TArguments ? {} : TArguments> =>\n    ({\n      kind,\n      ...parseModifiedTypeName(type),\n      arguments: extras.arguments ?? ({} as TArguments),\n    }) satisfies AnyTypeSpecifier as UnsafeOutputTypeSpecifier<\n      TName,\n      TModifier,\n      InputTypeSpecifiers extends TArguments ? {} : TArguments\n    >;\n};\n\nexport const unsafeOutputType = {\n  scalar: createUnsafeOutputTypeSpecifierFactory(\"scalar\"),\n  enum: createUnsafeOutputTypeSpecifierFactory(\"enum\"),\n  object: createUnsafeOutputTypeSpecifierFactory(\"object\"),\n  union: createUnsafeOutputTypeSpecifierFactory(\"union\"),\n  typename: createUnsafeOutputTypeSpecifierFactory(\"typename\"),\n};\n","import type {\n  EnumDefinition,\n  InputDefinition,\n  ObjectDefinition,\n  OperationRoots,\n  ScalarDefinition,\n  UnionDefinition,\n} from \"../types/schema\";\nimport { withTypeMeta } from \"../utils/type-meta\";\nimport { wrapByKey } from \"../utils/wrap-by-key\";\nimport { unsafeOutputType } from \"./type-specifier-builder\";\n\nexport const defineScalar = <const TName extends string, TInput, TOutput>(name: NoInfer<TName>) =>\n  wrapByKey(\n    name,\n    withTypeMeta({ name }) satisfies ScalarDefinition<{\n      name: TName;\n      input: TInput;\n      output: TOutput;\n    }>,\n  );\n\nexport const define = <const TName extends string>(name: TName) => ({\n  enum: <const TValues extends EnumDefinition<{ name: TName; values: string }>[\"values\"]>(values: TValues) =>\n    withTypeMeta({ name, values }) satisfies EnumDefinition<{\n      name: TName;\n      values: Extract<keyof TValues, string>;\n    }>,\n\n  input: <TFields extends InputDefinition[\"fields\"]>(fields: TFields) =>\n    ({\n      name,\n      fields,\n    }) satisfies InputDefinition,\n\n  object: <TFields extends ObjectDefinition[\"fields\"]>(fields: TFields) =>\n    ({\n      name,\n      fields: {\n        __typename: unsafeOutputType.typename(`${name}:!`, {}),\n        ...fields,\n      },\n    }) satisfies ObjectDefinition,\n\n  union: <TTypes extends UnionDefinition[\"types\"]>(types: TTypes) =>\n    ({\n      name,\n      types,\n    }) satisfies UnionDefinition,\n});\n\nexport const defineOperationRoots = <const TOperationRoots extends OperationRoots>(operationRoots: TOperationRoots) =>\n  operationRoots;\n"],"mappings":";;AAIA,MAAa,gBACX,WACY;AACZ,KAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,MAAK,OAAO,WAAW,YAAY,OAAO,WAAW,cAAe,WAAW,KAC7E,OAAM,IAAI,MAAM,0CAA0C;AAG5D,SAAO,eAAe,QAAQ,SAAS,EACrC,MAAM;AACJ,SAAM,IAAI,MAAM,kFAAkF;KAErG,CAAC;;AAGJ,QAAO;;;;;ACnBT,SAAgB,UAAwC,MAAa,OAAe;AAClF,QAAO,GACJ,OAAO,OACT;;;;;ACYH,SAAgB,sBACd,iBACA;AACA,KAAI,OAAO,oBAAoB,SAC7B,OAAM,IAAI,MAAM,+BAA+B,kBAAkB;CAGnE,MAAM,CAAC,MAAM,YAAY,gBAAgB,MAAM,IAAI;AACnD,QAAO;EAAE;EAAM;EAAU;;;;;ACX3B,MAAM,yCAA4E,SAAgB;AAchG,SAME,MACA,YAKC;EACC;EACA,GAAG,sBAAsB,KAAK;EAC9B,cAAc,OAAO,UAAU,EAAE,SAAS,OAAO,SAAS,EAAE,GAAG;EAChE;;AAGL,MAAa,kBAAkB;CAC7B,QAAQ,sCAAsC,SAAS;CACvD,MAAM,sCAAsC,OAAO;CACnD,OAAO,sCAAsC,QAAQ;CACtD;AAED,MAAM,0CAA8E,SAAgB;AAQlG,SACE,MACA,YAIC;EACC;EACA,GAAG,sBAAsB,KAAK;EAC9B,WAAW,OAAO,aAAc,EAAE;EACnC;;AAOL,MAAa,mBAAmB;CAC9B,QAAQ,uCAAuC,SAAS;CACxD,MAAM,uCAAuC,OAAO;CACpD,QAAQ,uCAAuC,SAAS;CACxD,OAAO,uCAAuC,QAAQ;CACtD,UAAU,uCAAuC,WAAW;CAC7D;;;;ACtED,MAAa,gBAA6D,SACxE,UACE,MACA,aAAa,EAAE,MAAM,CAAC,CAKvB;AAEH,MAAa,UAAsC,UAAiB;CAClE,OAAwF,WACtF,aAAa;EAAE;EAAM;EAAQ,CAAC;CAKhC,QAAmD,YAChD;EACC;EACA;EACD;CAEH,SAAqD,YAClD;EACC;EACA,QAAQ;GACN,YAAY,iBAAiB,SAAS,GAAG,KAAK,KAAK,EAAE,CAAC;GACtD,GAAG;GACJ;EACF;CAEH,QAAiD,WAC9C;EACC;EACA;EACD;CACJ;AAED,MAAa,wBAAsE,mBACjF"}