@zuplo/cli 6.71.22 → 6.71.25

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/types/index.d.ts

@@ -0,0 +1,219 @@
+import Ajv, { Options as AjvOptions } from 'ajv'
+
+type Build = typeof build
+
+declare namespace build {
+  interface BaseSchema {
+    /**
+     * Schema id
+     */
+    $id?: string
+    /**
+     * Schema title
+     */
+    title?: string;
+    /**
+     * Schema description
+     */
+    description?: string;
+    /**
+     * A comment to be added to the schema
+     */
+    $comment?: string;
+    /**
+     * Default value to be assigned when no value is given in the document
+     */
+    default?: any;
+    /**
+     * A list of example values that match this schema
+     */
+    examples?: any[];
+    /**
+     * Additional schema definition to reference from within the schema
+     */
+    definitions?: Record<string, Schema>
+    /**
+     * A set of schemas of which at least one must match
+     */
+    anyOf?: Partial<Schema>[];
+    /**
+     * A set of schemas which must all match
+     */
+    allOf?: Partial<Schema>[];
+    /**
+     * A conditional schema to check, controls schemas defined in `then` and `else`
+     */
+    if?: Partial<Schema>;
+    /**
+     * A schema to apply if the conditional schema from `if` passes
+     */
+    then?: Partial<Schema>;
+    /**
+     * A schema to apply if the conditional schema from `if` fails
+     */
+    else?: Partial<Schema>;
+    /**
+     * Open API 3.0 spec states that any value that can be null must be declared `nullable`
+     * @default false
+     */
+    nullable?: boolean;
+  }
+
+  export interface RefSchema {
+    /**
+     * A json-pointer to a schema to use as a reference
+     */
+    $ref: string;
+  }
+
+  export interface AnySchema extends BaseSchema {
+  }
+
+  export interface StringSchema extends BaseSchema {
+    type: 'string';
+    format?: string;
+  }
+
+  export interface IntegerSchema extends BaseSchema {
+    type: 'integer';
+  }
+
+  export interface NumberSchema extends BaseSchema {
+    type: 'number';
+  }
+
+  export interface NullSchema extends BaseSchema {
+    type: 'null';
+  }
+
+  export interface BooleanSchema extends BaseSchema {
+    type: 'boolean';
+  }
+
+  export interface ArraySchema extends BaseSchema {
+    type: 'array';
+    /**
+     * The schema for the items in the array
+     */
+    items: Schema | {}
+  }
+
+  export interface TupleSchema extends BaseSchema {
+    type: 'array';
+    /**
+     * The schemas for the items in the tuple
+     */
+    items: Schema[];
+  }
+
+  type ObjectProperties = Record<string, Partial<Schema>> & {
+    anyOf?: ObjectProperties[];
+    allOf?: ObjectProperties[];
+    if?: ObjectProperties;
+    then?: ObjectProperties;
+    else?: ObjectProperties;
+  }
+
+  export interface ObjectSchema extends BaseSchema {
+    type: 'object';
+    /**
+     * Describe the properties of the object
+     */
+    properties?: ObjectProperties;
+    /**
+     * The required properties of the object
+     */
+    required?: string[];
+    /**
+     * Describe properties that have keys following a given pattern
+     */
+    patternProperties?: ObjectProperties;
+    /**
+     * Specifies whether additional properties on the object are allowed, and optionally what schema they should
+     * adhere to
+     * @default false
+     */
+    additionalProperties?: Schema | boolean;
+  }
+
+  export type Schema =
+    | RefSchema
+    | StringSchema
+    | IntegerSchema
+    | NumberSchema
+    | NullSchema
+    | BooleanSchema
+    | ArraySchema
+    | TupleSchema
+    | ObjectSchema
+
+  export interface Options {
+    /**
+     * Optionally add an external definition to reference from your schema
+     */
+    schema?: Record<string, Schema>
+    /**
+     * Configure Ajv, which is used to evaluate conditional schemas and combined (anyOf) schemas
+     */
+    ajv?: AjvOptions
+    /**
+     * Optionally configure how the integer will be rounded
+     *
+     * @default 'trunc'
+     */
+    rounding?: 'ceil' | 'floor' | 'round' | 'trunc'
+    /**
+     * Running mode of fast-json-stringify
+     */
+    mode?: 'debug' | 'standalone'
+    /**
+     * Large arrays are defined as arrays containing, by default, `20000`
+     * elements or more. That value can be adjusted via the option parameter
+     * `largeArraySize`.
+     *
+     * @default 20000
+     */
+    largeArraySize?: number | string | BigInt
+    /**
+     * Specify the function on how large Arrays should be stringified.
+     *
+     * @default 'default'
+     */
+    largeArrayMechanism?: 'default' | 'json-stringify'
+  }
+
+  export const validLargeArrayMechanisms: string[]
+  export function restore (value: <TDoc extends object = object>(doc: TDoc) => string): ReturnType<Build>
+
+  export const build: Build
+  export { build as default }
+}
+
+interface DebugOption extends build.Options {
+  mode: 'debug'
+}
+
+interface StandaloneOption extends build.Options {
+  mode: 'standalone'
+}
+
+type StringCoercible = string | Date | RegExp
+type IntegerCoercible = number | BigInt
+
+/**
+ * Build a stringify function using a schema of the documents that should be stringified
+ * @param schema The schema used to stringify values
+ * @param options The options to use (optional)
+ */
+declare function build (schema: build.AnySchema, options: DebugOption): { code: string, ajv: Ajv }
+declare function build (schema: build.AnySchema, options: StandaloneOption): string
+declare function build (schema: build.AnySchema, options?: build.Options): <TDoc = any>(doc: TDoc) => any
+declare function build (schema: build.StringSchema, options?: build.Options): <TDoc extends StringCoercible = StringCoercible>(doc: TDoc) => string
+declare function build (schema: build.IntegerSchema | build.NumberSchema, options?: build.Options): <TDoc extends IntegerCoercible = IntegerCoercible>(doc: TDoc) => string
+declare function build (schema: build.NullSchema, options?: build.Options): <TDoc extends null = null>(doc: TDoc) => 'null'
+declare function build (schema: build.BooleanSchema, options?: build.Options): <TDoc extends boolean = boolean>(doc: TDoc) => string
+declare function build (schema: build.ArraySchema | build.TupleSchema, options?: build.Options): <TDoc extends any[]= any[]>(doc: TDoc) => string
+declare function build (schema: build.ObjectSchema, options?: build.Options): <TDoc extends object = object>(doc: TDoc) => string
+declare function build (schema: build.Schema, options?: build.Options): <TDoc = object | any[] | string | number | boolean | null> (doc: TDoc) => string
+
+export = build

package/node_modules/@fastify/fast-json-stringify-compiler/node_modules/fast-json-stringify/types/index.tst.ts

@@ -0,0 +1,259 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- Test using this disabled, see https://github.com/fastify/fast-json-stringify/pull/683
+import Ajv from 'ajv'
+import build, { restore, Schema, validLargeArrayMechanisms } from '..'
+import { expect } from 'tstyche'
+
+// Number schemas
+build({
+  type: 'number'
+})(25)
+build({
+  type: 'integer'
+})(-5)
+build({
+  type: 'integer'
+})(5n)
+
+build({
+  type: 'number'
+}, { rounding: 'ceil' })
+build({
+  type: 'number'
+}, { rounding: 'floor' })
+build({
+  type: 'number'
+}, { rounding: 'round' })
+build({
+  type: 'number'
+}, { rounding: 'trunc' })
+
+expect(build).type.not.toBeCallableWith({
+  type: 'number'
+}, { rounding: 'invalid' })
+
+// String schema
+build({
+  type: 'string'
+})('foobar')
+
+// Boolean schema
+build({
+  type: 'boolean'
+})(true)
+
+// Null schema
+build({
+  type: 'null'
+})(null)
+
+// Array schemas
+build({
+  type: 'array',
+  items: { type: 'number' }
+})([25])
+build({
+  type: 'array',
+  items: [{ type: 'string' }, { type: 'integer' }]
+})(['hello', 42])
+
+// Object schemas
+build({
+  type: 'object'
+})({})
+build({
+  type: 'object',
+  properties: {
+    foo: { type: 'string' },
+    bar: { type: 'integer' }
+  },
+  required: ['foo'],
+  patternProperties: {
+    'baz*': { type: 'null' }
+  },
+  additionalProperties: {
+    type: 'boolean'
+  }
+})({ foo: 'bar' })
+build({
+  type: 'object',
+  properties: {
+    foo: { type: 'string' },
+    bar: { type: 'integer' }
+  },
+  required: ['foo'],
+  patternProperties: {
+    'baz*': { type: 'null' }
+  },
+  additionalProperties: {
+    type: 'boolean'
+  }
+}, { rounding: 'floor' })({ foo: 'bar' })
+
+// Reference schemas
+build({
+  title: 'Example Schema',
+  definitions: {
+    num: {
+      type: 'object',
+      properties: {
+        int: {
+          type: 'integer'
+        }
+      }
+    },
+    str: {
+      type: 'string'
+    },
+    def: {
+      type: 'null'
+    }
+  },
+  type: 'object',
+  properties: {
+    nickname: {
+      $ref: '#/definitions/str'
+    }
+  },
+  patternProperties: {
+    num: {
+      $ref: '#/definitions/num'
+    }
+  },
+  additionalProperties: {
+    $ref: '#/definitions/def'
+  }
+})({ nickname: '', num: { int: 5 }, other: null })
+
+// Conditional/Combined schemas
+build({
+  title: 'Conditional/Combined Schema',
+  type: 'object',
+  properties: {
+    something: {
+      anyOf: [
+        { type: 'string' },
+        { type: 'boolean' }
+      ]
+    }
+  },
+  if: {
+    properties: {
+      something: { type: 'string' }
+    }
+  },
+  then: {
+    properties: {
+      somethingElse: { type: 'number' }
+    }
+  },
+  else: {
+    properties: {
+      somethingElse: { type: 'null' }
+    }
+  }
+})({ something: 'a string', somethingElse: 42 })
+
+// String schema with format
+build({
+  type: 'string',
+  format: 'date-time'
+})(new Date())
+
+/*
+This overload doesn't work yet -
+TypeScript chooses the generic for the schema
+before it chooses the overload for the options
+parameter.
+let str: string, ajv: Ajv
+str = build({
+    type: 'number'
+}, { debugMode: true }).code
+ajv = build({
+    type: 'number'
+}, { debugMode: true }).ajv
+str = build({
+    type: 'number'
+}, { mode: 'debug' }).code
+ajv = build({
+    type: 'number'
+}, { mode: 'debug' }).ajv
+str = build({
+    type: 'number'
+}, { mode: 'standalone' })
+*/
+const debugCompiled = build({
+  title: 'default string',
+  type: 'object',
+  properties: {
+    firstName: {
+      type: 'string'
+    }
+  }
+}, { mode: 'debug' })
+
+expect(build.restore(debugCompiled)).type.toBe(build({} as Schema))
+expect(restore(debugCompiled)).type.toBe(build({} as Schema))
+
+expect(build.validLargeArrayMechanisms).type.toBe<string[]>()
+expect(validLargeArrayMechanisms).type.toBe<string[]>()
+
+/**
+ * Schema inference
+ */
+
+// With inference
+interface InferenceSchema {
+  id: string;
+  a?: number;
+}
+
+const stringify3 = build({
+  type: 'object',
+  properties: { a: { type: 'string' } },
+})
+
+stringify3<InferenceSchema>({ id: '123' })
+stringify3<InferenceSchema>({ a: 123, id: '123' })
+expect(stringify3<InferenceSchema>).type.not.toBeCallableWith({ anotherOne: 'bar' })
+expect(stringify3<Schema>).type.not.toBeCallableWith({ a: 'bar' })
+
+// Without inference
+const stringify4 = build({
+  type: 'object',
+  properties: { a: { type: 'string' } },
+})
+stringify4({ id: '123' })
+stringify4({ a: 123, id: '123' })
+stringify4({ anotherOne: 'bar' })
+stringify4({ a: 'bar' })
+
+// Without inference - string type
+const stringify5 = build({
+  type: 'string',
+})
+stringify5('foo')
+expect(stringify5).type.not.toBeCallableWith({ id: '123' })
+
+// Without inference - null type
+const stringify6 = build({
+  type: 'null',
+})
+stringify6(null)
+expect(stringify6).type.not.toBeCallableWith('a string')
+
+// Without inference - boolean type
+const stringify7 = build({
+  type: 'boolean',
+})
+stringify7(true)
+expect(stringify7).type.not.toBeCallableWith('a string')
+
+// largeArrayMechanism
+build({}, { largeArrayMechanism: 'json-stringify' })
+build({}, { largeArrayMechanism: 'default' })
+expect(build).type.not.toBeCallableWith({} as Schema, { largeArrayMechanism: 'invalid' })
+
+build({}, { largeArraySize: 2000 })
+build({}, { largeArraySize: '2e4' })
+build({}, { largeArraySize: 2n })
+expect(build).type.not.toBeCallableWith({} as Schema, { largeArraySize: ['asdf'] })

package/node_modules/@fastify/fast-json-stringify-compiler/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fastify/fast-json-stringify-compiler",
   "description": "Build and manage the fast-json-stringify instances for the fastify framework",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
@@ -10,7 +10,7 @@
     "lint:fix": "eslint --fix",
     "unit": "c8 --100 node --test",
     "test": "npm run unit && npm run test:typescript",
-    "test:typescript": "tsd"
+    "test:typescript": "tstyche"
   },
   "repository": {
     "type": "git",
@@ -53,19 +53,14 @@
     }
   ],
   "devDependencies": {
-    "@fastify/pre-commit": "^2.1.0",
-    "c8": "^10.1.3",
+    "c8": "^11.0.0",
     "eslint": "^9.17.0",
     "fastify": "^5.0.0",
-    "neostandard": "^0.12.0",
+    "neostandard": "^0.13.0",
     "sanitize-filename": "^1.6.3",
-    "tsd": "^0.31.0"
+    "tstyche": "^7.1.0"
   },
-  "pre-commit": [
-    "lint",
-    "test"
-  ],
   "dependencies": {
-    "fast-json-stringify": "^6.0.0"
+    "fast-json-stringify": "^7.0.0"
   }
 }

package/node_modules/@fastify/fast-json-stringify-compiler/types/{index.test-d.ts → index.tst.ts}

@@ -1,4 +1,4 @@
-import { expectAssignable, expectError, expectType } from 'tsd'
+import { expect } from 'tstyche'
 import SerializerSelector, {
   RouteDefinition,
   Serializer,
@@ -14,12 +14,12 @@ import SerializerSelector, {
 
 {
   const compiler = SerializerSelector()
-  expectType<SerializerFactory>(compiler)
+  expect(compiler).type.toBe<SerializerFactory>()
 }
 
 {
   const compiler = SerializerSelectorNamed()
-  expectType<SerializerFactory>(compiler)
+  expect(compiler).type.toBe<SerializerFactory>()
 }
 
 {
@@ -34,13 +34,13 @@ import SerializerSelector, {
   const externalSchemas1 = {}
 
   const factory = SerializerSelector()
-  expectType<SerializerFactory>(factory)
+  expect(factory).type.toBe<SerializerFactory>()
   const compiler = factory(externalSchemas1, {})
-  expectType<SerializerCompiler>(compiler)
+  expect(compiler).type.toBe<SerializerCompiler>()
   const serializeFunc = compiler({ schema: sampleSchema, method: '', url: '', httpStatus: '' })
-  expectType<Serializer>(serializeFunc)
+  expect(serializeFunc).type.toBe<Serializer>()
 
-  expectType<string>(serializeFunc({ name: 'hello' }))
+  expect(serializeFunc({ name: 'hello' })).type.toBe<string>()
 }
 
 /**
@@ -49,21 +49,21 @@ import SerializerSelector, {
 
 const reader = StandaloneSerializer({
   readMode: true,
-  restoreFunction: (route: RouteDefinition) => {
-    expectAssignable<RouteDefinition>(route)
+  restoreFunction: (route) => {
+    expect(route).type.toBe<RouteDefinition>()
     return {} as Serializer
   },
 })
-expectType<SerializerFactory>(reader)
+expect(reader).type.toBe<SerializerFactory>()
 
 const writer = StandaloneSerializer({
   readMode: false,
-  storeFunction: (route: RouteDefinition, code: string) => {
-    expectAssignable<RouteDefinition>(route)
-    expectAssignable<string>(code)
+  storeFunction: (route, code) => {
+    expect(route).type.toBe<RouteDefinition>()
+    expect(code).type.toBe<string>()
   },
 })
-expectType<SerializerFactory>(writer)
+expect(writer).type.toBe<SerializerFactory>()
 
 {
   const base = {
@@ -100,43 +100,45 @@ expectType<SerializerFactory>(writer)
     [refSchema.$id]: refSchema
   }
 
-  expectError(StandaloneSerializer({
+  expect(StandaloneSerializer).type.not.toBeCallableWith({
     readMode: true,
     storeFunction () { }
-  }))
-  expectError(StandaloneSerializer({
+  })
+
+  expect(StandaloneSerializer).type.not.toBeCallableWith({
     readMode: false,
     restoreFunction () {}
-  }))
-  expectError(StandaloneSerializer({
+  })
+
+  expect(StandaloneSerializer).type.not.toBeCallableWith({
     restoreFunction () {}
-  }))
+  })
 
-  expectType<SerializerFactory>(StandaloneSerializer({
+  expect(StandaloneSerializer({
     storeFunction (routeOpts, schemaSerializerCode) {
-      expectType<RouteDefinition>(routeOpts)
-      expectType<string>(schemaSerializerCode)
+      expect(routeOpts).type.toBe<RouteDefinition>()
+      expect(schemaSerializerCode).type.toBe<string>()
     }
-  }))
+  })).type.toBe<SerializerFactory>()
 
-  expectType<SerializerFactory>(StandaloneSerializer({
+  expect(StandaloneSerializer({
     readMode: true,
     restoreFunction (routeOpts) {
-      expectType<RouteDefinition>(routeOpts)
+      expect(routeOpts).type.toBe<RouteDefinition>()
       return {} as Serializer
     }
-  }))
+  })).type.toBe<SerializerFactory>()
 
   const factory = StandaloneSerializer({
     readMode: false,
     storeFunction (routeOpts, schemaSerializerCode) {
-      expectType<RouteDefinition>(routeOpts)
-      expectType<string>(schemaSerializerCode)
+      expect(routeOpts).type.toBe<RouteDefinition>()
+      expect(schemaSerializerCode).type.toBe<string>()
     }
   })
-  expectType<SerializerFactory>(factory)
+  expect(factory).type.toBe<SerializerFactory>()
 
   const compiler = factory(schemaMap)
-  expectType<SerializerCompiler>(compiler)
-  expectType<Serializer>(compiler(endpointSchema))
+  expect(compiler).type.toBe<SerializerCompiler>()
+  expect(compiler(endpointSchema)).type.toBe<Serializer>()
 }

package/node_modules/@posthog/core/dist/posthog-core-stateless.d.ts

@@ -9,6 +9,7 @@ declare class PostHogFetchNetworkError extends Error {
     constructor(error: unknown);
 }
 export declare const maybeAdd: (key: string, value: JsonType | undefined) => Record<string, JsonType>;
+export declare const applyCallerFeatureFlagOverrides: (target: PostHogEventProperties, callerProperties: PostHogEventProperties) => void;
 export declare function logFlushError(err: any): Promise<void>;
 /**
  * True for the network error PostHog throws when a request fails to reach the server
@@ -55,6 +56,7 @@ export declare abstract class PostHogCoreStateless {
     private maxQueueSize;
     private flushInterval;
     private flushPromise;
+    private flushPromises;
     private shutdownPromise;
     private requestTimeout;
     private featureFlagsRequestTimeoutMs;
@@ -222,6 +224,7 @@ export declare abstract class PostHogCoreStateless {
      * Avoids unnecessary promise errors
      */
     private flushBackground;
+    private waitForPendingPromises;
     /**
      * Flushes the queue of pending events.
      *
@@ -250,7 +253,9 @@ export declare abstract class PostHogCoreStateless {
      * @throws PostHogFetchNetworkError
      * @throws Error
      */
+    protected flushWithPendingPromises(): Promise<void>;
     flush(): Promise<void>;
+    private flushInternal;
     protected getCustomHeaders(): {
         [key: string]: string;
     };