@confect/core 1.0.0-next.0

package/src/Types.ts

@@ -0,0 +1,166 @@
+import type {
+  DocumentByName,
+  FieldTypeFromFieldPath,
+  GenericDatabaseReader,
+  GenericDataModel,
+  TableNamesInDataModel,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import type { Brand } from "effect";
+
+export type IsOptional<T, K extends keyof T> =
+  {} extends Pick<T, K> ? true : false;
+
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+
+export type IsUnion<T, U extends T = T> = T extends unknown
+  ? [U] extends [T]
+    ? false
+    : true
+  : never;
+
+// https://stackoverflow.com/a/52806744
+export type IsValueLiteral<Vl> = [Vl] extends [never]
+  ? never
+  : IsUnion<Vl> extends true
+    ? false
+    : [Vl] extends [string | number | bigint | boolean]
+      ? [string] extends [Vl]
+        ? false
+        : [number] extends [Vl]
+          ? false
+          : [boolean] extends [Vl]
+            ? false
+            : [bigint] extends [Vl]
+              ? false
+              : true
+      : false;
+
+/**
+ * Only checks for records with string keys.
+ */
+export type IsRecord<T> = [T] extends [never]
+  ? false
+  : IsUnion<T> extends true
+    ? false
+    : T extends Record<string, infer V>
+      ? string extends keyof T
+        ? keyof T extends string
+          ? T extends Record<string, V>
+            ? Record<string, V> extends T
+              ? true
+              : false
+            : false
+          : false
+        : false
+      : false;
+
+export type DeepMutable<T> =
+  IsAny<T> extends true
+    ? any
+    : T extends Brand.Brand<any> | GenericId<any>
+      ? T
+      : T extends ReadonlyMap<infer K, infer V>
+        ? Map<DeepMutable<K>, DeepMutable<V>>
+        : T extends ReadonlySet<infer V>
+          ? Set<DeepMutable<V>>
+          : [keyof T] extends [never]
+            ? T
+            : { -readonly [K in keyof T]: DeepMutable<T[K]> };
+
+export type DeepReadonly<T> =
+  IsAny<T> extends true
+    ? any
+    : T extends Map<infer K, infer V>
+      ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
+      : T extends Set<infer V>
+        ? ReadonlySet<DeepReadonly<V>>
+        : [keyof T] extends [never]
+          ? T
+          : { readonly [K in keyof T]: DeepReadonly<T[K]> };
+
+export type TypeError<Message extends string, T = never> = [Message, T];
+
+export type TypeDefect<Message extends string, T = never> = TypeError<
+  `Unexpected type error:\n  ${Message}`,
+  T
+>;
+
+export type IsRecursive<T> = true extends DetectCycle<T> ? true : false;
+
+type DetectCycle<T, Cache extends any[] = []> =
+  IsAny<T> extends true
+    ? false
+    : [T] extends [any]
+      ? T extends Cache[number]
+        ? true
+        : T extends Array<infer U>
+          ? DetectCycle<U, [...Cache, T]>
+          : T extends Map<infer _U, infer V>
+            ? DetectCycle<V, [...Cache, T]>
+            : T extends Set<infer U>
+              ? DetectCycle<U, [...Cache, T]>
+              : T extends object
+                ? true extends {
+                    [K in keyof T]: DetectCycle<T[K], [...Cache, T]>;
+                  }[keyof T]
+                  ? true
+                  : false
+                : false
+      : never;
+
+//////////////////////////////////
+// START: Vendored from Arktype //
+//////////////////////////////////
+
+// https://github.com/arktypeio/arktype/blob/2e911d01a741ccee7a17e31ee144049817fabbb8/ark/util/unionToTuple.ts#L9
+
+export type UnionToTuple<t> =
+  _unionToTuple<t, []> extends infer result ? conform<result, t[]> : never;
+
+type _unionToTuple<t, result extends unknown[]> =
+  getLastBranch<t> extends infer current
+    ? [t] extends [never]
+      ? result
+      : _unionToTuple<Exclude<t, current>, [current, ...result]>
+    : never;
+
+type getLastBranch<t> =
+  intersectUnion<t extends unknown ? (x: t) => void : never> extends (
+    x: infer branch,
+  ) => void
+    ? branch
+    : never;
+
+type intersectUnion<t> = (t extends unknown ? (_: t) => void : never) extends (
+  _: infer intersection,
+) => void
+  ? intersection
+  : never;
+
+type conform<t, base> = t extends base ? t : base;
+
+////////////////////////////////
+// END: Vendored from Arktype //
+////////////////////////////////
+
+export type IndexFieldTypesForEq<
+  ConvexDataModel extends GenericDataModel,
+  Table extends TableNamesInDataModel<ConvexDataModel>,
+  T extends string[],
+> = T extends readonly [...infer Rest, any]
+  ? Rest extends readonly string[]
+    ? {
+        [K in keyof Rest]: FieldTypeFromFieldPath<
+          DocumentByName<ConvexDataModel, Table>,
+          Rest[K]
+        >;
+      }
+    : never
+  : never;
+
+// Would prefer to use `BaseDatabaseReader` from the `convex` package, but it's not exported.
+export type BaseDatabaseReader<DataModel extends GenericDataModel> = {
+  get: GenericDatabaseReader<DataModel>["get"];
+  query: GenericDatabaseReader<DataModel>["query"];
+};

package/src/UserIdentity.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+
+export const UserIdentity = <CustomClaimsFields extends Schema.Struct.Fields>(
+  customClaimsFields: CustomClaimsFields,
+) =>
+  Schema.Struct({
+    ...customClaimsFields,
+    tokenIdentifier: Schema.String,
+    subject: Schema.String,
+    issuer: Schema.String,
+    name: Schema.optionalWith(Schema.String, { exact: true }),
+    givenName: Schema.optionalWith(Schema.String, { exact: true }),
+    familyName: Schema.optionalWith(Schema.String, { exact: true }),
+    nickname: Schema.optionalWith(Schema.String, { exact: true }),
+    preferredUsername: Schema.optionalWith(Schema.String, { exact: true }),
+    profileUrl: Schema.optionalWith(Schema.String, { exact: true }),
+    pictureUrl: Schema.optionalWith(Schema.String, { exact: true }),
+    email: Schema.optionalWith(Schema.String, { exact: true }),
+    emailVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),
+    gender: Schema.optionalWith(Schema.String, { exact: true }),
+    birthday: Schema.optionalWith(Schema.String, { exact: true }),
+    timezone: Schema.optionalWith(Schema.String, { exact: true }),
+    language: Schema.optionalWith(Schema.String, { exact: true }),
+    phoneNumber: Schema.optionalWith(Schema.String, { exact: true }),
+    phoneNumberVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),
+    address: Schema.optionalWith(Schema.String, { exact: true }),
+    updatedAt: Schema.optionalWith(Schema.String, { exact: true }),
+  });

package/src/index.ts

@@ -0,0 +1,11 @@
+export * as FunctionSpec from "./FunctionSpec";
+export * as GenericId from "./GenericId";
+export * as GroupPath from "./GroupPath";
+export * as GroupSpec from "./GroupSpec";
+export * as PaginationResult from "./PaginationResult";
+export * as Ref from "./Ref";
+export * as Refs from "./Refs";
+export * as Spec from "./Spec";
+export * as SystemFields from "./SystemFields";
+export * as Types from "./Types";
+export * as UserIdentity from "./UserIdentity";

package/src/internal/utils.ts

@@ -0,0 +1,86 @@
+const RESERVED_JS_IDENTIFIERS = new Set([
+  // Reserved keywords
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "export",
+  "extends",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  // Future reserved keywords
+  "await",
+  "enum",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  // Literal values that cannot be reassigned
+  "null",
+  "true",
+  "false",
+  // Global objects that shouldn't be shadowed
+  "undefined",
+]);
+
+const RESERVED_CONVEX_FILE_NAMES = new Set(["schema", "http", "crons"]);
+
+const jsIdentifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+const isReservedJsIdentifier = (identifier: string) =>
+  RESERVED_JS_IDENTIFIERS.has(identifier);
+
+const isReservedConvexFileName = (fileName: string) =>
+  RESERVED_CONVEX_FILE_NAMES.has(fileName);
+
+const matchesJsIdentifierPattern = (identifier: string) =>
+  jsIdentifierRegex.test(identifier);
+
+export const validateConfectFunctionIdentifier = (identifier: string) => {
+  if (!matchesJsIdentifierPattern(identifier)) {
+    throw new Error(
+      `Expected a valid Confect function identifier, but received: "${identifier}". Valid identifiers must start with a letter, underscore, or dollar sign, and can only contain letters, numbers, underscores, or dollar signs.`,
+    );
+  }
+
+  if (isReservedJsIdentifier(identifier)) {
+    throw new Error(
+      `Expected a valid Confect function identifier, but received: "${identifier}". "${identifier}" is a reserved JavaScript identifier.`,
+    );
+  }
+
+  if (isReservedConvexFileName(identifier)) {
+    throw new Error(
+      `Expected a valid Confect function identifier, but received: "${identifier}". "${identifier}" is a reserved Convex file name.`,
+    );
+  }
+};