@codecks/fetch 0.1.0 → 0.1.2

package/dist/query-type-MH8IxqbW.d.ts

@@ -0,0 +1,182 @@
+//#region src/models/_type-helpers.d.ts
+declare const __nominal__type: unique symbol;
+type FilterNeverKeys<T> = { [K in keyof T as T[K] extends never ? never : K]: T[K] };
+type Nominal<Type, Identifier> = Type & {
+  readonly [__nominal__type]: Identifier;
+};
+//#endregion
+//#region src/models/_fields.d.ts
+type TypedField<K extends string, X, Opts extends BaseOpts> = {
+  type: K;
+  _: [X, Opts];
+};
+type BaseOpts = {
+  optional?: boolean;
+};
+type FieldEntry = TypedField<string, any, any>;
+type InferSimpleFieldEntry<T extends FieldEntry> = T extends TypedField<any, infer X, infer Opts> ? Opts extends {
+  optional: true;
+} ? X | null | "yes" : X : never;
+//#endregion
+//#region src/models/_desc.d.ts
+type ModelDesc<TName extends string, TFields extends FieldDesc, TRelations extends RelationsDesc, TKey extends (keyof TFields & string)[]> = {
+  name: TName;
+  keys: TKey;
+  fields: TFields;
+  relations: TRelations;
+};
+type AnyDesc = ModelDesc<any, any, any, any[]>;
+type FieldDesc = Record<string, FieldEntry>;
+type BelongsToOpts<TFk extends string> = {
+  type: "belongsTo";
+  fk: TFk;
+};
+type HasManyOpts = {
+  type: "hasMany";
+};
+type HasOneOpts = {
+  type: "hasOne";
+};
+type RelationOpts = BelongsToOpts<any> | HasManyOpts | HasOneOpts;
+type RelationEntry<TRelName extends string, TOpts extends RelationOpts> = {
+  relName: TRelName;
+  options: TOpts;
+};
+type RelationsDesc = Record<string, RelationEntry<any, any>>;
+type InferFieldType<T extends FieldEntry> = T extends FieldEntry ? InferSimpleFieldEntry<T> : never;
+//#endregion
+//#region src/has-many-filter-type.d.ts
+type ModelMap$1 = Record<string, AnyDesc>;
+type OneOrArray<T> = T | T[];
+type NormalAndNegatedKeys<T> = T & { [K in keyof T & string as `!${K}`]: T[K] };
+type OrderString<T extends string> = `${T}` | `-${T}`;
+type OrderExpr<T> = {
+  field: T;
+  dir: "asc" | "desc";
+};
+type Order<T extends AnyDesc> = OneOrArray<OrderString<keyof T["fields"] extends string ? keyof T["fields"] : never>> | OneOrArray<OrderExpr<T["fields"]>>;
+type Operators<T> = {
+  op: "lt" | "lte" | "gt" | "gte";
+  value: T;
+} | {
+  op: "eq" | "neq";
+  value: T | null;
+} | {
+  op: "in" | "notIn";
+  value: T[];
+} | (T extends string ? {
+  op: "contains";
+  value: string;
+} : never) | (T extends Array<infer El> ? {
+  op: "has";
+  value: El;
+} | {
+  op: "overlaps";
+  value: El[];
+} : never);
+type FieldQuery<T extends AnyDesc> = { [K in keyof T["fields"]]?: null | OneOrArray<InferFieldType<T["fields"][K]>> | Operators<InferFieldType<T["fields"][K]>> };
+type RelationQuery<T extends AnyDesc, TMap extends ModelMap$1> = NormalAndNegatedKeys<{ [K in keyof T["relations"]]?: SimpleFilter<TMap[T["relations"][K]["relName"]], TMap> }>;
+type SimpleFilter<T extends AnyDesc, TMap extends ModelMap$1> = FieldQuery<T> | RelationQuery<T, TMap>;
+type Filter<T extends AnyDesc, TMap extends ModelMap$1> = SimpleFilter<T, TMap> & {
+  $and?: Filter<T, TMap>[];
+  $or?: Filter<T, TMap>[];
+};
+//#endregion
+//#region src/query-type.d.ts
+type ModelMap = Record<string, AnyDesc>;
+type SerializableRelationQuery = {
+  asField: true;
+} | {
+  asField: false;
+  fields?: string[];
+  relations?: Record<string, SerializableRelationQuery>;
+};
+interface ModelQuery<T extends AnyDesc, TMap extends ModelMap> {
+  fields?: (keyof T["fields"] & string)[];
+  relations?: RelQuery<T, TMap>;
+}
+interface SimpleHasManyQuery<T extends AnyDesc, TMap extends ModelMap> extends ModelQuery<T, TMap> {
+  type?: "query";
+  orderBy?: Order<T>;
+  limit?: number;
+  offset?: number;
+  filter?: Filter<T, TMap>;
+  as?: string;
+}
+interface CountOrExistQuery<T extends AnyDesc, TMap extends ModelMap> {
+  type: "count" | "exists";
+  filter?: Filter<T, TMap>;
+  as: string;
+  fields?: never;
+  relations?: never;
+}
+interface FirstOrLastQuery<T extends AnyDesc, TMap extends ModelMap> extends ModelQuery<T, TMap> {
+  type: "first";
+  filter?: Filter<T, TMap>;
+  as: string;
+  orderBy: Order<T>;
+}
+type HasManyQuery<T extends AnyDesc, TMap extends ModelMap> = SimpleHasManyQuery<T, TMap> | CountOrExistQuery<T, TMap> | FirstOrLastQuery<T, TMap>;
+type AbstractHasManyQuery = (ModelQuery<any, any> & {
+  type?: "query" | "first";
+  as?: string;
+}) | {
+  type: "count" | "exists";
+  as: string;
+};
+type HasManyQueryWithAs<T extends AnyDesc, TMap extends ModelMap> = HasManyQuery<T, TMap> & {
+  as: string;
+};
+type HasManyRelQueryEntry<T extends AnyDesc, TMap extends ModelMap, K extends keyof ExtractHasMany<T, TMap>> = HasManyQuery<TMap[T["relations"][K]["relName"]], TMap> | HasManyQueryWithAs<TMap[T["relations"][K]["relName"]], TMap>[];
+type RelQueryEntry<T extends AnyDesc, TMap extends ModelMap, K extends keyof T["relations"]> = K extends keyof ExtractHasMany<T, TMap> ? HasManyRelQueryEntry<T, TMap, K> : ModelQuery<TMap[T["relations"][K]["relName"]], TMap>;
+/**
+ * examples for account:
+ * {disabledBy: {fields: []}} // belongst
+ * {cards: {fields: []}}
+ * {cards: [{as: "myCards", fields: []}]}
+ */
+type RelQuery<T extends AnyDesc, TMap extends ModelMap> = { [K in keyof T["relations"]]?: RelQueryEntry<T, TMap, K> };
+type EnsureModelQuery<T> = T extends ModelQuery<any, any> ? T : never;
+type EnsureHasManyQuery<T> = T extends AbstractHasManyQuery ? T : never;
+type EnrichBelongsTo<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<any, infer Opts> ? Opts extends BelongsToOpts<infer TFk> ? {
+  model: TMap[M["relations"][K]["relName"]];
+  fk: TFk;
+  field: M["fields"][TFk] extends TypedField<"belongsTo", infer FieldType, infer FieldOpts> ? {
+    type: FieldType;
+  } & FieldOpts : never;
+} : never : never }>;
+type ExtractHasMany<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
+  type: "hasMany";
+}> ? {
+  model: TMap[RelName];
+} : never }>;
+type ExtractHasOne<M extends AnyDesc, TMap extends ModelMap> = FilterNeverKeys<{ [K in keyof M["relations"]]: M["relations"][K] extends RelationEntry<infer RelName, {
+  type: "hasOne";
+}> ? {
+  model: TMap[RelName];
+} : never }>;
+type InferModelQuery<M extends AnyDesc, Q extends ModelQuery<M, TMap>, TMap extends ModelMap> = (Q["fields"] extends (keyof M["fields"])[] ? { [K in Q["fields"][number]]: InferFieldType<M["fields"][K]> } : {}) & (Q["relations"] extends RelQuery<M, TMap> ? InferRelQuery<M, Q["relations"], TMap> : {}) & { [K in M["keys"][number] & string]: InferFieldType<M["fields"][K]> } & {
+  "~model": M["name"];
+  "~key": string;
+};
+type IsOptional<T, Test> = Test extends true ? T | null : T;
+type EmptyObjIfNever<T> = [T] extends [never] ? {} : T;
+type ExtractRelQueryArray<M extends AnyDesc, TMap extends ModelMap, Q extends RelQuery<M, TMap>> = { [K in keyof Q]: K extends keyof ExtractHasMany<M, TMap> ? Q[K] extends HasManyQueryWithAs<any, any>[] ? { [Item in Q[K][number] as Item["as"]]: InferHasMany<ExtractHasMany<M, TMap>[K]["model"], TMap, Item> } : never : never }[keyof Q];
+type InferHasMany<M extends AnyDesc, TMap extends ModelMap, QM extends HasManyQuery<M, TMap>> = QM extends {
+  type: "count";
+} ? number : QM extends {
+  type: "exist";
+} ? boolean : QM extends {
+  type: "first";
+} ? InferModelQuery<M, EnsureModelQuery<QM>, TMap> | null : InferModelQuery<M, EnsureModelQuery<QM>, TMap>[];
+type InferRelEntry<M extends AnyDesc, TMap extends ModelMap, Q extends RelQuery<any, any>, K extends keyof Q> = K extends keyof EnrichBelongsTo<M, TMap> ? IsOptional<InferModelQuery<EnrichBelongsTo<M, TMap>[K]["model"], EnsureModelQuery<Q[K]>, TMap>, EnrichBelongsTo<M, TMap>[K]["field"]["optional"]> : K extends keyof ExtractHasMany<M, TMap> ? InferHasMany<ExtractHasMany<M, TMap>[K]["model"], TMap, EnsureHasManyQuery<Q[K]>> : K extends keyof ExtractHasOne<M, TMap> ? InferModelQuery<ExtractHasOne<M, TMap>[K]["model"], EnsureModelQuery<Q[K]>, TMap> : never;
+type InferKeyName<Q extends RelQuery<any, any>, K extends keyof Q> = Q[K] extends Array<any> ? never : Q[K] extends {
+  as: string;
+} ? K extends keyof ExtractHasMany<any, any> ? Q[K]["as"] : K : K;
+type InferRelQuery<M extends AnyDesc, Q extends RelQuery<M, TMap>, TMap extends ModelMap> = EmptyObjIfNever<ExtractRelQueryArray<M, TMap, Q>> & EmptyObjIfNever<{ [K in keyof Q as InferKeyName<Q, K>]: InferRelEntry<M, TMap, Q, K> }>;
+type Instance<M extends keyof ModelMap> = {
+  "~model": M;
+  "~key": string;
+};
+//#endregion
+export { AnyDesc, InferModelQuery, InferRelQuery, Instance, ModelDesc, ModelQuery, Nominal, RelQuery, RelationEntry, SerializableRelationQuery, TypedField };

package/dist/store-mAj3G67A.d.ts

@@ -0,0 +1,44 @@
+import { AnyDesc, ModelQuery } from "./query-type-MH8IxqbW.js";
+import { BaseLoader, LoaderResult } from "./loader-types-DJdGWL4B.js";
+
+//#region src/_exploration/immediate-cache.d.ts
+type FieldMeta = {
+  state: "fresh";
+} | {
+  state: "dirty";
+};
+interface FieldCache<T = any> {
+  value: T;
+  partKeys: string[];
+  meta: FieldMeta;
+}
+type ModelInstance = Map<string, FieldCache>;
+type ModelCache = Map<string, ModelInstance>;
+declare class ImmediateCache {
+  cache: ModelCache;
+  partKeyToFields: Map<string, FieldCache<any>[]>;
+  private getInstanceKey;
+  get(model: string, key: string, field: string): FieldCache | undefined;
+  set(model: string, key: string, partialInstance: Record<string, {
+    value: unknown;
+    partKeys: string[];
+  }>, meta: FieldMeta): void;
+  setMetaByPartKeys(partKeys: string[], meta: FieldMeta): void;
+}
+//#endregion
+//#region src/_exploration/store.d.ts
+declare class Store {
+  private loader;
+  cache: ImmediateCache;
+  modelMap: Record<string, AnyDesc>;
+  constructor(loader: BaseLoader);
+  loadData(model: string, ids: string[], q: ModelQuery<any, any>, acceptDirty?: boolean, iteration?: number): LoaderResult;
+  onLoaded(model: string, key: string, partialInstance: Record<string, unknown>): void;
+  /**
+   * Recursively check if query data is in cache
+   * Accumulates missing requests in the missingRequests array
+   */
+  private checkQueryRecursive;
+}
+//#endregion
+export { Store };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codecks/fetch",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Quickly create deeply nested queries for the Codecks API with advanced TypeScript support",
   "type": "module",
   "license": "MIT",