@dataform/core 3.0.11 → 3.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/bundle.d.ts CHANGED
@@ -16,6 +16,34 @@ interface INamedConfig {
16
16
  type?: string;
17
17
  name?: string;
18
18
  }
19
+ interface IActionConfig {
20
+ tags?: string[];
21
+ dependencies?: Resolvable | Resolvable[];
22
+ disabled?: boolean;
23
+ }
24
+ interface ITargetableConfig {
25
+ database?: string;
26
+ schema?: string;
27
+ }
28
+ interface IDependenciesConfig {
29
+ dependencies?: Resolvable | Resolvable[];
30
+ hermetic?: boolean;
31
+ dependOnDependencyAssertions?: boolean;
32
+ }
33
+ interface IDocumentableConfig {
34
+ columns?: IColumnsDescriptor;
35
+ description?: string;
36
+ }
37
+ interface IColumnsDescriptor {
38
+ [name: string]: string | IRecordDescriptor;
39
+ }
40
+ interface IRecordDescriptor {
41
+ description?: string;
42
+ columns?: IColumnsDescriptor;
43
+ displayName?: string;
44
+ tags?: string | string[];
45
+ bigqueryPolicyTags?: string | string[];
46
+ }
19
47
  interface ITarget {
20
48
  database?: string;
21
49
  schema?: string;
@@ -2112,6 +2140,9 @@ namespace dataform {
2112
2140
 
2113
2141
  /** DataPreparationConfig description */
2114
2142
  description?: (string|null);
2143
+
2144
+ /** DataPreparationConfig errorTable */
2145
+ errorTable?: (dataform.ActionConfig.DataPreparationConfig.IErrorTableConfig|null);
2115
2146
  }
2116
2147
 
2117
2148
  /** Represents a DataPreparationConfig. */
@@ -2141,6 +2172,9 @@ namespace dataform {
2141
2172
  /** DataPreparationConfig description. */
2142
2173
  public description: string;
2143
2174
 
2175
+ /** DataPreparationConfig errorTable. */
2176
+ public errorTable?: (dataform.ActionConfig.DataPreparationConfig.IErrorTableConfig|null);
2177
+
2144
2178
  /**
2145
2179
  * Creates a new DataPreparationConfig instance using the specified properties.
2146
2180
  * @param [properties] Properties to set
@@ -2218,6 +2252,124 @@ namespace dataform {
2218
2252
  */
2219
2253
  public static getTypeUrl(typeUrlPrefix?: string): string;
2220
2254
  }
2255
+
2256
+ namespace DataPreparationConfig {
2257
+
2258
+ /** Properties of an ErrorTableConfig. */
2259
+ interface IErrorTableConfig {
2260
+
2261
+ /** ErrorTableConfig name */
2262
+ name?: (string|null);
2263
+
2264
+ /** ErrorTableConfig dataset */
2265
+ dataset?: (string|null);
2266
+
2267
+ /** ErrorTableConfig project */
2268
+ project?: (string|null);
2269
+
2270
+ /** ErrorTableConfig retentionDays */
2271
+ retentionDays?: (number|null);
2272
+ }
2273
+
2274
+ /** Represents an ErrorTableConfig. */
2275
+ class ErrorTableConfig implements IErrorTableConfig {
2276
+
2277
+ /**
2278
+ * Constructs a new ErrorTableConfig.
2279
+ * @param [properties] Properties to set
2280
+ */
2281
+ constructor(properties?: dataform.ActionConfig.DataPreparationConfig.IErrorTableConfig);
2282
+
2283
+ /** ErrorTableConfig name. */
2284
+ public name: string;
2285
+
2286
+ /** ErrorTableConfig dataset. */
2287
+ public dataset: string;
2288
+
2289
+ /** ErrorTableConfig project. */
2290
+ public project: string;
2291
+
2292
+ /** ErrorTableConfig retentionDays. */
2293
+ public retentionDays: number;
2294
+
2295
+ /**
2296
+ * Creates a new ErrorTableConfig instance using the specified properties.
2297
+ * @param [properties] Properties to set
2298
+ * @returns ErrorTableConfig instance
2299
+ */
2300
+ public static create(properties?: dataform.ActionConfig.DataPreparationConfig.IErrorTableConfig): dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig;
2301
+
2302
+ /**
2303
+ * Encodes the specified ErrorTableConfig message. Does not implicitly {@link dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig.verify|verify} messages.
2304
+ * @param message ErrorTableConfig message or plain object to encode
2305
+ * @param [writer] Writer to encode to
2306
+ * @returns Writer
2307
+ */
2308
+ public static encode(message: dataform.ActionConfig.DataPreparationConfig.IErrorTableConfig, writer?: $protobuf.Writer): $protobuf.Writer;
2309
+
2310
+ /**
2311
+ * Encodes the specified ErrorTableConfig message, length delimited. Does not implicitly {@link dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig.verify|verify} messages.
2312
+ * @param message ErrorTableConfig message or plain object to encode
2313
+ * @param [writer] Writer to encode to
2314
+ * @returns Writer
2315
+ */
2316
+ public static encodeDelimited(message: dataform.ActionConfig.DataPreparationConfig.IErrorTableConfig, writer?: $protobuf.Writer): $protobuf.Writer;
2317
+
2318
+ /**
2319
+ * Decodes an ErrorTableConfig message from the specified reader or buffer.
2320
+ * @param reader Reader or buffer to decode from
2321
+ * @param [length] Message length if known beforehand
2322
+ * @returns ErrorTableConfig
2323
+ * @throws {Error} If the payload is not a reader or valid buffer
2324
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
2325
+ */
2326
+ public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig;
2327
+
2328
+ /**
2329
+ * Decodes an ErrorTableConfig message from the specified reader or buffer, length delimited.
2330
+ * @param reader Reader or buffer to decode from
2331
+ * @returns ErrorTableConfig
2332
+ * @throws {Error} If the payload is not a reader or valid buffer
2333
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
2334
+ */
2335
+ public static decodeDelimited(reader: ($protobuf.Reader|Uint8Array)): dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig;
2336
+
2337
+ /**
2338
+ * Verifies an ErrorTableConfig message.
2339
+ * @param message Plain object to verify
2340
+ * @returns `null` if valid, otherwise the reason why it is not
2341
+ */
2342
+ public static verify(message: { [k: string]: any }): (string|null);
2343
+
2344
+ /**
2345
+ * Creates an ErrorTableConfig message from a plain object. Also converts values to their respective internal types.
2346
+ * @param object Plain object
2347
+ * @returns ErrorTableConfig
2348
+ */
2349
+ public static fromObject(object: { [k: string]: any }): dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig;
2350
+
2351
+ /**
2352
+ * Creates a plain object from an ErrorTableConfig message. Also converts values to other types if specified.
2353
+ * @param message ErrorTableConfig
2354
+ * @param [options] Conversion options
2355
+ * @returns Plain object
2356
+ */
2357
+ public static toObject(message: dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig, options?: $protobuf.IConversionOptions): { [k: string]: any };
2358
+
2359
+ /**
2360
+ * Converts this ErrorTableConfig to JSON.
2361
+ * @returns JSON object
2362
+ */
2363
+ public toJSON(): { [k: string]: any };
2364
+
2365
+ /**
2366
+ * Gets the default type url for ErrorTableConfig
2367
+ * @param [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
2368
+ * @returns The default type url
2369
+ */
2370
+ public static getTypeUrl(typeUrlPrefix?: string): string;
2371
+ }
2372
+ }
2221
2373
  }
2222
2374
 
2223
2375
  /** Properties of a NotebookRuntimeOptionsConfig. */
@@ -4334,6 +4486,15 @@ namespace dataform {
4334
4486
 
4335
4487
  /** DataPreparation dataPreparationYaml */
4336
4488
  dataPreparationYaml?: (string|null);
4489
+
4490
+ /** DataPreparation query */
4491
+ query?: (string|null);
4492
+
4493
+ /** DataPreparation errorTable */
4494
+ errorTable?: (dataform.ITarget|null);
4495
+
4496
+ /** DataPreparation errorTableRetentionDays */
4497
+ errorTableRetentionDays?: (number|null);
4337
4498
  }
4338
4499
 
4339
4500
  /** Represents a DataPreparation. */
@@ -4370,7 +4531,19 @@ namespace dataform {
4370
4531
  public disabled: boolean;
4371
4532
 
4372
4533
  /** DataPreparation dataPreparationYaml. */
4373
- public dataPreparationYaml: string;
4534
+ public dataPreparationYaml?: (string|null);
4535
+
4536
+ /** DataPreparation query. */
4537
+ public query?: (string|null);
4538
+
4539
+ /** DataPreparation errorTable. */
4540
+ public errorTable?: (dataform.ITarget|null);
4541
+
4542
+ /** DataPreparation errorTableRetentionDays. */
4543
+ public errorTableRetentionDays: number;
4544
+
4545
+ /** DataPreparation definition. */
4546
+ public definition?: ("dataPreparationYaml"|"query");
4374
4547
 
4375
4548
  /**
4376
4549
  * Creates a new DataPreparation instance using the specified properties.
@@ -7372,18 +7545,44 @@ declare class AssertionContext implements ICommonContext {
7372
7545
 
7373
7546
  declare class DataPreparation extends ActionBuilder<dataform.DataPreparation> {
7374
7547
  session: Session;
7548
+ contextableQuery: Contextable<IDataPreparationContext, string>;
7375
7549
  proto: dataform.IDataPreparation;
7376
7550
  constructor(session?: Session, config?: dataform.ActionConfig.DataPreparationConfig, configPath?: string);
7377
7551
  config(config: any): this;
7552
+ query(query: Contextable<IDataPreparationContext, string>): this;
7378
7553
  dependencies(value: Resolvable | Resolvable[]): this;
7379
7554
  getFileName(): string;
7380
7555
  getTarget(): dataform.Target;
7381
7556
  compile(): dataform.DataPreparation;
7382
- private resolveEmpty;
7383
- private resolveTargets;
7557
+ database(database: string): this;
7558
+ schema(schema: string): this;
7559
+ private configureYamlWithoutTargets;
7560
+ private configureYamlWithTargets;
7384
7561
  private applySessionToDataPreparationContents;
7385
7562
  private applySessionToTableReference;
7386
7563
  private getTargets;
7564
+ private configureYaml;
7565
+ private configureSqlx;
7566
+ }
7567
+ interface IDataPreparationContext extends ITableContext {
7568
+ validate: (exp: string) => string;
7569
+ }
7570
+ declare class DataPreparationContext implements IDataPreparationContext {
7571
+ private dataPreparation;
7572
+ private isIncremental;
7573
+ constructor(dataPreparation: DataPreparation, isIncremental?: boolean);
7574
+ config(config: dataform.ActionConfig.DataPreparationConfig.ErrorTableConfig): string;
7575
+ self(): string;
7576
+ name(): string;
7577
+ ref(ref: Resolvable | string[], ...rest: string[]): string;
7578
+ resolve(ref: Resolvable | string[], ...rest: string[]): string;
7579
+ schema(): string;
7580
+ database(): string;
7581
+ when(cond: boolean, trueCase: string, falseCase?: string): string;
7582
+ incremental(): boolean;
7583
+ dependencies(res: Resolvable): string;
7584
+ validate(exp: string): string;
7585
+ apply<T>(value: Contextable<IDataPreparationContext, T>): T;
7387
7586
  }
7388
7587
 
7389
7588
  declare class Declaration extends ActionBuilder<dataform.Declaration> {
@@ -7398,15 +7597,6 @@ declare class Declaration extends ActionBuilder<dataform.Declaration> {
7398
7597
  private verifyConfig;
7399
7598
  }
7400
7599
 
7401
- interface ILegacyIncrementalTableConfig extends dataform.ActionConfig.IncrementalTableConfig {
7402
- dependencies: Resolvable[];
7403
- database: string;
7404
- schema: string;
7405
- fileName: string;
7406
- type: string;
7407
- bigquery?: ILegacyTableBigqueryConfig;
7408
- assertions: any;
7409
- }
7410
7600
  declare class IncrementalTable extends ActionBuilder<dataform.Table> {
7411
7601
  proto: dataform.ITable;
7412
7602
  session: Session;
@@ -7417,7 +7607,10 @@ declare class IncrementalTable extends ActionBuilder<dataform.Table> {
7417
7607
  private contextablePostOps;
7418
7608
  private uniqueKeyAssertions;
7419
7609
  private rowConditionsAssertion;
7610
+ private unverifiedConfig;
7611
+ private configPath;
7420
7612
  constructor(session?: Session, unverifiedConfig?: any, configPath?: string);
7613
+ type(type: TableType): this;
7421
7614
  query(query: Contextable<ITableContext, string>): this;
7422
7615
  where(where: Contextable<ITableContext, string>): this;
7423
7616
  preOps(pres: Contextable<ITableContext, string | string[]>): this;
@@ -7494,24 +7687,7 @@ declare class OperationContext implements ICommonContext {
7494
7687
  apply<T>(value: Contextable<ICommonContext, T>): T;
7495
7688
  }
7496
7689
 
7497
- interface ILegacyViewBigqueryConfig {
7498
- labels: {
7499
- [key: string]: string;
7500
- };
7501
- additionalOptions: {
7502
- [key: string]: string;
7503
- };
7504
- }
7505
- interface ILegacyViewConfig extends dataform.ActionConfig.ViewConfig {
7506
- dependencies: Resolvable[];
7507
- database: string;
7508
- schema: string;
7509
- fileName: string;
7510
- type: string;
7511
- bigquery: ILegacyViewBigqueryConfig;
7512
- assertions: any;
7513
- }
7514
- declare class View extends ActionBuilder<dataform.Table> {
7690
+ declare class Table extends ActionBuilder<dataform.Table> {
7515
7691
  proto: dataform.ITable;
7516
7692
  session: Session;
7517
7693
  dependOnDependencyAssertions: boolean;
@@ -7521,13 +7697,15 @@ declare class View extends ActionBuilder<dataform.Table> {
7521
7697
  private contextablePostOps;
7522
7698
  private uniqueKeyAssertions;
7523
7699
  private rowConditionsAssertion;
7700
+ private unverifiedConfig;
7701
+ private configPath;
7524
7702
  constructor(session?: Session, unverifiedConfig?: any, configPath?: string);
7703
+ type(type: TableType): this;
7525
7704
  query(query: Contextable<ITableContext, string>): this;
7526
7705
  where(where: Contextable<ITableContext, string>): this;
7527
7706
  preOps(pres: Contextable<ITableContext, string | string[]>): this;
7528
7707
  postOps(posts: Contextable<ITableContext, string | string[]>): this;
7529
7708
  disabled(disabled?: boolean): this;
7530
- materialized(materialized: boolean): void;
7531
7709
  bigquery(bigquery: dataform.IBigQueryOptions): this;
7532
7710
  dependencies(value: Resolvable | Resolvable[]): this;
7533
7711
  hermetic(hermetic: boolean): void;
@@ -7544,19 +7722,30 @@ declare class View extends ActionBuilder<dataform.Table> {
7544
7722
  private contextifyOps;
7545
7723
  private verifyConfig;
7546
7724
  }
7547
-
7548
- declare const TableType: readonly ["table", "view", "incremental"];
7549
- declare type TableType = typeof TableType[number];
7550
- interface ILegacyTableConfig extends dataform.ActionConfig.TableConfig {
7551
- dependencies: Resolvable[];
7552
- database: string;
7553
- schema: string;
7554
- fileName: string;
7555
- type: string;
7556
- bigquery?: ILegacyTableBigqueryConfig;
7557
- assertions: any;
7725
+ declare class TableContext implements ITableContext {
7726
+ private table;
7727
+ private isIncremental;
7728
+ constructor(table: Table, isIncremental?: boolean);
7729
+ self(): string;
7730
+ name(): string;
7731
+ ref(ref: Resolvable | string[], ...rest: string[]): string;
7732
+ resolve(ref: Resolvable | string[], ...rest: string[]): string;
7733
+ schema(): string;
7734
+ database(): string;
7735
+ type(type: TableType): string;
7736
+ where(where: Contextable<ITableContext, string>): string;
7737
+ when(cond: boolean, trueCase: string, falseCase?: string): string;
7738
+ incremental(): boolean;
7739
+ preOps(statement: Contextable<ITableContext, string | string[]>): string;
7740
+ postOps(statement: Contextable<ITableContext, string | string[]>): string;
7741
+ disabled(): string;
7742
+ bigquery(bigquery: dataform.IBigQueryOptions): string;
7743
+ dependencies(res: Resolvable): string;
7744
+ apply<T>(value: Contextable<ITableContext, T>): T;
7745
+ tags(tags: string[]): string;
7558
7746
  }
7559
- declare class Table extends ActionBuilder<dataform.Table> {
7747
+
7748
+ declare class View extends ActionBuilder<dataform.Table> {
7560
7749
  proto: dataform.ITable;
7561
7750
  session: Session;
7562
7751
  dependOnDependencyAssertions: boolean;
@@ -7566,13 +7755,16 @@ declare class Table extends ActionBuilder<dataform.Table> {
7566
7755
  private contextablePostOps;
7567
7756
  private uniqueKeyAssertions;
7568
7757
  private rowConditionsAssertion;
7758
+ private unverifiedConfig;
7759
+ private configPath;
7569
7760
  constructor(session?: Session, unverifiedConfig?: any, configPath?: string);
7570
- type(type: TableType): this | View | IncrementalTable;
7761
+ type(type: TableType): this;
7571
7762
  query(query: Contextable<ITableContext, string>): this;
7572
7763
  where(where: Contextable<ITableContext, string>): this;
7573
7764
  preOps(pres: Contextable<ITableContext, string | string[]>): this;
7574
7765
  postOps(posts: Contextable<ITableContext, string | string[]>): this;
7575
7766
  disabled(disabled?: boolean): this;
7767
+ materialized(materialized: boolean): void;
7576
7768
  bigquery(bigquery: dataform.IBigQueryOptions): this;
7577
7769
  dependencies(value: Resolvable | Resolvable[]): this;
7578
7770
  hermetic(hermetic: boolean): void;
@@ -7589,28 +7781,6 @@ declare class Table extends ActionBuilder<dataform.Table> {
7589
7781
  private contextifyOps;
7590
7782
  private verifyConfig;
7591
7783
  }
7592
- declare class TableContext implements ITableContext {
7593
- private table;
7594
- private isIncremental;
7595
- constructor(table: Table, isIncremental?: boolean);
7596
- self(): string;
7597
- name(): string;
7598
- ref(ref: Resolvable | string[], ...rest: string[]): string;
7599
- resolve(ref: Resolvable | string[], ...rest: string[]): string;
7600
- schema(): string;
7601
- database(): string;
7602
- type(type: TableType): string;
7603
- where(where: Contextable<ITableContext, string>): string;
7604
- when(cond: boolean, trueCase: string, falseCase?: string): string;
7605
- incremental(): boolean;
7606
- preOps(statement: Contextable<ITableContext, string | string[]>): string;
7607
- postOps(statement: Contextable<ITableContext, string | string[]>): string;
7608
- disabled(): string;
7609
- bigquery(bigquery: dataform.IBigQueryOptions): string;
7610
- dependencies(res: Resolvable): string;
7611
- apply<T>(value: Contextable<ITableContext, T>): T;
7612
- tags(tags: string[]): string;
7613
- }
7614
7784
 
7615
7785
  declare type Action = Table | View | IncrementalTable | Operation | Assertion | Declaration | Notebook | DataPreparation;
7616
7786
  declare abstract class ActionBuilder<T> {
@@ -7628,19 +7798,35 @@ interface ITableContext extends ICommonContext {
7628
7798
  when: (cond: boolean, trueCase: string, falseCase?: string) => string;
7629
7799
  incremental: () => boolean;
7630
7800
  }
7631
- interface ILegacyTableBigqueryConfig {
7801
+ declare type TableType = typeof TableType[number];
7802
+ declare const TableType: readonly ["table", "view", "incremental"];
7803
+ interface ILegacyTableConfig extends IActionConfig, IDependenciesConfig, IDocumentableConfig, INamedConfig, ITargetableConfig {
7804
+ type?: TableType;
7805
+ protected?: boolean;
7806
+ bigquery?: ILegacyBigQueryOptions;
7807
+ assertions?: ILegacyTableAssertions;
7808
+ uniqueKey?: string[];
7809
+ materialized?: boolean;
7810
+ }
7811
+ interface ILegacyBigQueryOptions {
7632
7812
  partitionBy?: string;
7633
7813
  clusterBy?: string[];
7634
7814
  updatePartitionFilter?: string;
7635
7815
  labels?: {
7636
- [key: string]: string;
7816
+ [name: string]: string;
7637
7817
  };
7638
7818
  partitionExpirationDays?: number;
7639
7819
  requirePartitionFilter?: boolean;
7640
7820
  additionalOptions?: {
7641
- [key: string]: string;
7821
+ [name: string]: string;
7642
7822
  };
7643
7823
  }
7824
+ interface ILegacyTableAssertions {
7825
+ uniqueKey?: string | string[];
7826
+ uniqueKeys?: string[][];
7827
+ nonNull?: string | string[];
7828
+ rowConditions?: string[];
7829
+ }
7644
7830
 
7645
7831
  interface IStringifier<T> {
7646
7832
  stringify: (value: T) => string;
@@ -7710,7 +7896,7 @@ declare class Session {
7710
7896
  sqlxAction(actionOptions: {
7711
7897
  sqlxConfig: any;
7712
7898
  sqlStatementCount: number;
7713
- sqlContextable: (ctx: TableContext | AssertionContext | OperationContext | ICommonContext) => string[];
7899
+ sqlContextable: (ctx: TableContext | AssertionContext | OperationContext | DataPreparationContext | IDataPreparationContext | ICommonContext) => string[];
7714
7900
  incrementalWhereContextable: (ctx: ITableContext) => string;
7715
7901
  preOperationsContextable: (ctx: ITableContext) => string[];
7716
7902
  postOperationsContextable: (ctx: ITableContext) => string[];
@@ -7721,7 +7907,7 @@ declare class Session {
7721
7907
  }): void;
7722
7908
  resolve(ref: Resolvable | string[], ...rest: string[]): string;
7723
7909
  operate(name: string, queries?: Contextable<ICommonContext, string | string[]>): Operation;
7724
- publish(name: string, queryOrConfig?: Contextable<ITableContext, string> | ILegacyTableConfig | ILegacyViewConfig | ILegacyIncrementalTableConfig): Table | IncrementalTable | View;
7910
+ publish(name: string, queryOrConfig?: Contextable<ITableContext, string> | dataform.ActionConfig.TableConfig | dataform.ActionConfig.ViewConfig | dataform.ActionConfig.IncrementalTableConfig | ILegacyTableConfig | any): Table | IncrementalTable | View;
7725
7911
  assert(name: string, query?: AContextable<string>): Assertion;
7726
7912
  declare(dataset: dataform.ITarget): Declaration;
7727
7913
  test(name: string): Test;
@@ -7755,7 +7941,7 @@ declare class ActionMap {
7755
7941
  private setBySchemaLevel;
7756
7942
  }
7757
7943
 
7758
- declare const version = "3.0.11";
7944
+ declare const version = "3.0.13";
7759
7945
 
7760
7946
  declare const session: Session;
7761
7947
  declare const supportedFeatures: dataform.SupportedFeatures[];