adds the extracted @gadgetinc/core package

Author: infiton

packages/api-client-core/src/types.ts

@@ -11,6 +11,17 @@ import type {
   ViewFunctionWithVariables,
 } from "./GadgetFunctions.js";
 
+/**
+ * Allows detecting an any type, this is rather tricky:
+ * The type constraint 0 extends 1 is not satisfied (0 is not assignable to 1),
+ * so it should be impossible for 0 extends (1 & T) to be satisfied either, since (1 & T) should be even narrower than 1.
+ * However, when T is any, it reduces 0 extends (1 & any) to 0 extends any, which is satisfied.
+ * That's because any is intentionally unsound and acts as both a supertype and subtype of almost every other type.
+ * source: https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
+ */
+
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+
 /**
  * Limit the keys in T to only those that also exist in U. AKA Subset or Intersection.
  */
@@ -33,10 +44,25 @@ export type VariablesOptions = Record<string, VariableOptions>;
  * Given an options object from a find method, default the type of the selection to a default if no selection is passed
  */
 export type DefaultSelection<
-  SelectionType,
-  Options extends { select?: SelectionType | null },
-  Defaults extends SelectionType
-> = Options["select"] extends SelectionType ? Options["select"] : Defaults;
+  Available extends FieldSelection,
+  Options extends { select?: Available | null },
+  Defaults extends SomeFieldsSelected<Available>
+> = IfAny<Options, Defaults, IfAny<Options["select"], Defaults, Options["select"] extends Available ? Options["select"] : Defaults>>;
+
+/**
+ * Take a FieldSelection type and construct a type with all its fields required and selected.
+ */
+export type AllFieldsSelected<Selection extends FieldSelection> = {
+  [K in keyof Selection]-?: NonNullable<Selection[K]> extends FieldSelection ? AllFieldsSelected<NonNullable<Selection[K]>> : true;
+};
+
+/**
+ * Take a FieldSelection type and construct a type with its fields set to true
+ * rather than (boolean | null | undefined)
+ */
+export type SomeFieldsSelected<Selection extends FieldSelection> = {
+  [K in keyof Selection]?: NonNullable<Selection[K]> extends FieldSelection ? SomeFieldsSelected<NonNullable<Selection[K]>> : true;
+};
 
 /**
  * Describes an option set that accepts a selection
@@ -56,6 +82,16 @@ export interface BaseFindOptions<SelectionType = any> {
   live?: boolean;
 }
 
+/**
+ * Filter out any keys in `T` that are mapped to `never` recursively. Any nested objects that are empty after having never valued keys removed are also removed.
+ *
+ * ```typescript
+ * type Thing = DeepFilterNever<
+ *  { a: { b: never }, c: string }
+ * >;  // { c: string; }
+ * ```
+ */
+
 /**
  * Get any keys of `Selection` that are not mapped to `never`
  */
@@ -66,21 +102,36 @@ export type NonNeverKeys<Selection> = {
 /**
  * Filter out any keys in `T` that are mapped to `never`.
  */
+
 export type FilterNever<T extends Record<string, unknown>> = NonNeverKeys<T> extends never ? never : { [Key in NonNeverKeys<T>]: T[Key] };
 
-type InnerSelect<Schema, Selection extends FieldSelection | null | undefined> = Selection extends null | undefined
-  ? never
-  : Schema extends (infer T)[]
-  ? InnerSelect<T, Selection>[]
-  : Schema extends null
-  ? InnerSelect<Exclude<Schema, null>, Selection> | null
-  : {
-      [Key in keyof Selection & keyof Schema]: Selection[Key] extends true
-        ? Schema[Key]
-        : Selection[Key] extends FieldSelection
-        ? InnerSelect<Schema[Key], Selection[Key]>
-        : never;
-    };
+/**
+ * Extract a subset of a schema given a selection
+ *
+ * ```typescript
+ * type Selection = Select<
+ *  { apple: "red", banana: "yellow", orange: "orange" },
+ *  { apple: true, banana: false }
+ * >;  // { apple: "red" }
+ * ```
+ */
+type InnerSelect<Schema, Selection extends FieldSelection | null | undefined> = IfAny<
+  Selection,
+  never,
+  Selection extends null | undefined
+    ? never
+    : Schema extends (infer T)[]
+    ? InnerSelect<T, Selection>[]
+    : Schema extends null
+    ? InnerSelect<Exclude<Schema, null>, Selection> | null
+    : {
+        [Key in keyof Selection & keyof Schema]: Selection[Key] extends true
+          ? Schema[Key]
+          : Selection[Key] extends FieldSelection
+          ? InnerSelect<Schema[Key], Selection[Key]>
+          : never;
+      }
+>;
 
 /**
  * Filter out any keys in `T` that are mapped to `never` recursively. Any nested objects that are empty after having never valued keys removed are also removed.
@@ -757,6 +808,7 @@ export type PaginateOptions = {
   select?: AnySelection | InternalFieldSelection | null;
 };
 
+/**
 /**
  * Convert a schema type into the type that a selection of it must extend
  *
@@ -780,9 +832,11 @@ export type PaginateOptions = {
  *   }
  * }
  */
-export type AvailableSelection<Schema> = Schema extends string | number | bigint | null | undefined
-  ? boolean | null | undefined
-  : { [key in keyof Schema]?: AvailableSelection<Schema[key]> };
+export type AvailableSelection<Schema> = Schema extends Array<infer T>
+  ? AvailableSelection<T>
+  : Schema extends object
+  ? { [key in keyof Schema]?: AvailableSelection<Schema[key]> }
+  : boolean | null | undefined;
 
 /** Options for configuring the queue for a background action */
 export interface BackgroundActionQueue {

packages/core/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@gadgetinc/core",
+  "version": "0.1.0",
+  "files": [
+    "README.md",
+    "dist/**/*"
+  ],
+  "license": "MIT",
+  "repository": "github:gadget-inc/js-clients",
+  "homepage": "https://github.com/gadget-inc/js-clients/tree/main/packages/core",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "source": "src/index.ts",
+  "main": "dist/cjs/index.js",
+  "sideEffects": false,
+  "scripts": {
+    "typecheck:main": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist/ *.tsbuildinfo **/*.tsbuildinfo",
+    "prebuild": "mkdir -p dist/cjs dist/esm && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json && echo '{\"type\": \"module\"}' > dist/esm/package.json",
+    "build": "pnpm clean && pnpm prebuild && tsc -b tsconfig.cjs.json tsconfig.esm.json",
+    "prepublishOnly": "pnpm build",
+    "prerelease": "gitpkg publish"
+  },
+  "dependencies": {
+    "klona": "^2.0.6"
+  },
+  "peerDependencies": {
+    "@urql/core": "*",
+    "graphql": "*",
+    "graphql-ws": "*"
+  },
+  "devDependencies": {
+    "type-fest": "^3.13.1"
+  }
+}

packages/core/src/AnyClient.ts

@@ -0,0 +1,30 @@
+import type { AnyConnection } from "./AnyConnection.js";
+import type { GadgetTransaction } from "./GadgetTransaction.js";
+import type { AnyInternalModelManager } from "./InternalModelManager.js";
+
+export const $modelRelationships = Symbol.for("gadget/modelRelationships");
+
+export type InternalModelManagerNamespace = {
+  // internal model managers can be maps of model names to model managers, subnamespaces, or utility functions
+  [key: string]: AnyInternalModelManager | InternalModelManagerNamespace | ((...args: any[]) => any);
+};
+
+/**
+ * An instance of any Gadget app's API client object
+ */
+export interface AnyClient {
+  connection: AnyConnection;
+  query(graphQL: string, variables?: Record<string, any>): Promise<any>;
+  mutate(graphQL: string, variables?: Record<string, any>): Promise<any>;
+  transaction<T>(callback: (transaction: GadgetTransaction) => Promise<T>): Promise<T>;
+  internal: InternalModelManagerNamespace;
+  apiClientCoreVersion?: string;
+  [$modelRelationships]?: { [modelName: string]: { [apiIdentifier: string]: { type: string; model: string } } };
+}
+
+/**
+ * Checks if the given object is an instance of any Gadget app's generated JS client object
+ */
+export const isGadgetClient = (client: any): client is AnyClient => {
+  return client && "connection" in client && client.connection && "endpoint" in client.connection;
+};

packages/core/src/AnyConnection.ts

@@ -0,0 +1,56 @@
+import type { Client, ClientOptions } from "@urql/core";
+import type { ClientOptions as SubscriptionClientOptions, createClient as createSubscriptionClient } from "graphql-ws";
+import type { AuthenticationModeOptions, Exchanges } from "./ClientOptions.js";
+import { GadgetTransaction } from "./GadgetTransaction.js";
+
+export interface GadgetSubscriptionClientOptions extends Partial<SubscriptionClientOptions> {
+  urlParams?: Record<string, string | null | undefined>;
+  connectionAttempts?: number;
+  connectionGlobalTimeoutMs?: number;
+}
+
+/**
+ * Represents the current strategy for authenticating with the Gadget platform.
+ * For individual users in web browsers, we authenticate using a session token stored client side, like a cookie, but with cross domain support.
+ * For server to server communication, or traceable access from the browser, we use pre shared secrets called API Keys
+ * And when within the Gadget platform itself, we use a private secret token called an Internal Auth Token. Internal Auth Tokens are managed by Gadget and should never be used by external developers.
+ **/
+export enum AuthenticationMode {
+  BrowserSession = "browser-session",
+  APIKey = "api-key",
+  Internal = "internal",
+  InternalAuthToken = "internal-auth-token",
+  Anonymous = "anonymous",
+  Custom = "custom",
+}
+
+export interface GadgetConnectionOptions {
+  endpoint: string;
+  authenticationMode?: AuthenticationModeOptions;
+  websocketsEndpoint?: string;
+  subscriptionClientOptions?: GadgetSubscriptionClientOptions;
+  websocketImplementation?: typeof globalThis.WebSocket;
+  fetchImplementation?: typeof globalThis.fetch;
+  environment?: string;
+  requestPolicy?: ClientOptions["requestPolicy"];
+  applicationId?: string;
+  baseRouteURL?: string;
+  exchanges?: Exchanges;
+  createSubscriptionClient?: typeof createSubscriptionClient;
+}
+
+export type TransactionRun<T> = (transaction: GadgetTransaction) => Promise<T>;
+
+export interface AnyConnection {
+  endpoint: string;
+  authenticationMode: AuthenticationMode;
+  createSubscriptionClient: typeof createSubscriptionClient;
+  options: GadgetConnectionOptions;
+  get currentClient(): Client;
+  transaction: {
+    <T>(options: GadgetSubscriptionClientOptions, run: TransactionRun<T>): Promise<T>;
+    <T>(run: TransactionRun<T>): Promise<T>;
+  };
+  close(): void;
+  fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+}