@mikarinneoracle/oci-cdk-code-only-preview 0.0.13 → 0.0.15

package/README.md

@@ -133,7 +133,7 @@ export OCI_FUNCTION_APP_NAME='my-existing-function-app'
 
 These settings are optional: `OCI_CODE_ONLY_SOURCE_DIR` (defaults to the current directory), `OCI_FUNCTION_MEMORY_MB` (from `func.yaml`, otherwise `256`), and `OCI_FUNCTION_TIMEOUT_SECONDS` (from `func.yaml`, otherwise `30`). `OCI_TENANCY_ID`, `OCI_REGION`, and `OCI_NAMESPACE` are also optional when they can be resolved from the active OCI CLI profile.
 
-Each deploy re-builds `<function-name>.zip` in the project root and uploads that file. The ZIP has the required `function/` directory at its root, includes source files, and excludes `node_modules`, `.git`, `.tools`, `.terraform`, and `cdktf.out`. A successful code-only destroy removes this ZIP after Terraform has destroyed the Function App and infrastructure. The current preview path is function-only: it does not create an API Gateway because the CLI-managed function OCID is not in Terraform state.
+Each deploy re-builds `<function-name>.zip` in the project root and uploads that file. The ZIP has the required `function/` directory at its root, includes source files, and excludes `node_modules`, `.git`, `.tools`, `.terraform`, and `cdktf.out`. A successful code-only destroy removes this ZIP after Terraform has destroyed the Function App and infrastructure. With the default `OCI_STACK_ACTION=full-stack`, OCDK creates the API Gateway and uses a Terraform data source to resolve the CLI-managed function OCID for its route. The first code-only deploy therefore runs Terraform once to create the Function App, uploads the function, then runs Terraform again to create the Gateway deployment. Set `OCI_STACK_ACTION=function-only` to omit API Gateway.
 
 After a successful code-only deploy, OCDK writes the log IDs for `npx ocdk tail:execution-log` automatically.
 

package/bin/ocdk.js

@@ -154,12 +154,26 @@ if (command === 'deploy' && codeOnlyEnabled) {
     console.error('Missing script: "deploy-code-only". Update @mikarinneoracle/oci-cdk.');
     process.exit(1);
   }
-  const env = {
+  const requestedStackAction = (process.env.OCI_STACK_ACTION || 'full-stack').trim().toLowerCase();
+  const wantsFullStack = requestedStackAction !== 'function-only' && requestedStackAction !== 'function';
+  const baseEnv = {
     ...process.env,
     OCI_CODE_ONLY: '1',
-    OCI_STACK_ACTION: 'function-only',
     OCI_PROJECT_DIR: projectDir,
   };
+  // On a new project, create the Function App first. Later code-only deploys
+  // keep the full Terraform graph, including the existing API Gateway route.
+  let hasFunctionApp = false;
+  try {
+    resolveCodeOnlyFunctionAppId(baseEnv);
+    hasFunctionApp = true;
+  } catch {
+    // No state/output yet: the bootstrap Terraform pass creates the app.
+  }
+  const env = {
+    ...baseEnv,
+    OCI_STACK_ACTION: hasFunctionApp ? requestedStackAction : 'function-only',
+  };
   const infrastructure = spawnSync('npm', ['run', '--silent', 'deploy', '--', ...passthroughArgs], {
     stdio: 'inherit',
     cwd: root,
@@ -181,6 +195,16 @@ if (command === 'deploy' && codeOnlyEnabled) {
     env: { ...env, OCI_FUNCTION_APP_ID: functionAppId },
   });
   if (result.status !== 0) process.exit(result.status ?? 1);
+  if (wantsFullStack && !hasFunctionApp) {
+    console.log('Creating API Gateway deployment for the code-only function...');
+    const apiGatewayDeploy = spawnSync('npm', ['run', '--silent', 'deploy', '--', ...passthroughArgs], {
+      stdio: 'inherit',
+      cwd: root,
+      shell: false,
+      env: { ...baseEnv, OCI_STACK_ACTION: 'full-stack' },
+    });
+    if (apiGatewayDeploy.status !== 0) process.exit(apiGatewayDeploy.status ?? 1);
+  }
   const logConfig = spawnSync('node', [path.join(root, 'bin', 'write-log-config.js')], {
     stdio: 'inherit',
     cwd: projectDir,

package/lib/.gen/providers/oci/data-oci-functions-functions/index.d.ts

@@ -0,0 +1,295 @@
+import { Construct } from 'constructs';
+import * as cdktf from 'cdktf';
+export interface DataOciFunctionsFunctionsConfig extends cdktf.TerraformMetaArguments {
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#application_id DataOciFunctionsFunctions#application_id}
+    */
+    readonly applicationId: string;
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#display_name DataOciFunctionsFunctions#display_name}
+    */
+    readonly displayName?: string;
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#id DataOciFunctionsFunctions#id}
+    *
+    * Please be aware that the id field is automatically added to all resources in Terraform providers using a Terraform provider SDK version below 2.
+    * If you experience problems setting this value it might not be settable. Please take a look at the provider documentation to ensure it should be settable.
+    */
+    readonly id?: string;
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#state DataOciFunctionsFunctions#state}
+    */
+    readonly state?: string;
+    /**
+    * filter block
+    *
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#filter DataOciFunctionsFunctions#filter}
+    */
+    readonly filter?: DataOciFunctionsFunctionsFilter[] | cdktf.IResolvable;
+}
+export interface DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfig {
+}
+export declare function dataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfigToTerraform(struct?: DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfig): any;
+export declare function dataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfigToHclTerraform(struct?: DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfig): any;
+export declare class DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfigOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean);
+    get internalValue(): DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfig | undefined;
+    set internalValue(value: DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfig | undefined);
+    get count(): number;
+    get strategy(): string;
+}
+export declare class DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfigList extends cdktf.ComplexList {
+    protected terraformResource: cdktf.IInterpolatingParent;
+    protected terraformAttribute: string;
+    protected wrapsSet: boolean;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean);
+    /**
+    * @param index the index of the item to return
+    */
+    get(index: number): DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfigOutputReference;
+}
+export interface DataOciFunctionsFunctionsFunctionsSourceDetails {
+}
+export declare function dataOciFunctionsFunctionsFunctionsSourceDetailsToTerraform(struct?: DataOciFunctionsFunctionsFunctionsSourceDetails): any;
+export declare function dataOciFunctionsFunctionsFunctionsSourceDetailsToHclTerraform(struct?: DataOciFunctionsFunctionsFunctionsSourceDetails): any;
+export declare class DataOciFunctionsFunctionsFunctionsSourceDetailsOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean);
+    get internalValue(): DataOciFunctionsFunctionsFunctionsSourceDetails | undefined;
+    set internalValue(value: DataOciFunctionsFunctionsFunctionsSourceDetails | undefined);
+    get pbfListingId(): string;
+    get sourceType(): string;
+}
+export declare class DataOciFunctionsFunctionsFunctionsSourceDetailsList extends cdktf.ComplexList {
+    protected terraformResource: cdktf.IInterpolatingParent;
+    protected terraformAttribute: string;
+    protected wrapsSet: boolean;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean);
+    /**
+    * @param index the index of the item to return
+    */
+    get(index: number): DataOciFunctionsFunctionsFunctionsSourceDetailsOutputReference;
+}
+export interface DataOciFunctionsFunctionsFunctionsTraceConfig {
+}
+export declare function dataOciFunctionsFunctionsFunctionsTraceConfigToTerraform(struct?: DataOciFunctionsFunctionsFunctionsTraceConfig): any;
+export declare function dataOciFunctionsFunctionsFunctionsTraceConfigToHclTerraform(struct?: DataOciFunctionsFunctionsFunctionsTraceConfig): any;
+export declare class DataOciFunctionsFunctionsFunctionsTraceConfigOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean);
+    get internalValue(): DataOciFunctionsFunctionsFunctionsTraceConfig | undefined;
+    set internalValue(value: DataOciFunctionsFunctionsFunctionsTraceConfig | undefined);
+    get isEnabled(): cdktf.IResolvable;
+}
+export declare class DataOciFunctionsFunctionsFunctionsTraceConfigList extends cdktf.ComplexList {
+    protected terraformResource: cdktf.IInterpolatingParent;
+    protected terraformAttribute: string;
+    protected wrapsSet: boolean;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean);
+    /**
+    * @param index the index of the item to return
+    */
+    get(index: number): DataOciFunctionsFunctionsFunctionsTraceConfigOutputReference;
+}
+export interface DataOciFunctionsFunctionsFunctions {
+}
+export declare function dataOciFunctionsFunctionsFunctionsToTerraform(struct?: DataOciFunctionsFunctionsFunctions): any;
+export declare function dataOciFunctionsFunctionsFunctionsToHclTerraform(struct?: DataOciFunctionsFunctionsFunctions): any;
+export declare class DataOciFunctionsFunctionsFunctionsOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean);
+    get internalValue(): DataOciFunctionsFunctionsFunctions | undefined;
+    set internalValue(value: DataOciFunctionsFunctionsFunctions | undefined);
+    get applicationId(): string;
+    get compartmentId(): string;
+    private _config;
+    get config(): cdktf.StringMap;
+    private _definedTags;
+    get definedTags(): cdktf.StringMap;
+    get displayName(): string;
+    private _freeformTags;
+    get freeformTags(): cdktf.StringMap;
+    get id(): string;
+    get image(): string;
+    get imageDigest(): string;
+    get invokeEndpoint(): string;
+    get memoryInMbs(): string;
+    private _provisionedConcurrencyConfig;
+    get provisionedConcurrencyConfig(): DataOciFunctionsFunctionsFunctionsProvisionedConcurrencyConfigList;
+    get shape(): string;
+    private _sourceDetails;
+    get sourceDetails(): DataOciFunctionsFunctionsFunctionsSourceDetailsList;
+    get state(): string;
+    get timeCreated(): string;
+    get timeUpdated(): string;
+    get timeoutInSeconds(): number;
+    private _traceConfig;
+    get traceConfig(): DataOciFunctionsFunctionsFunctionsTraceConfigList;
+}
+export declare class DataOciFunctionsFunctionsFunctionsList extends cdktf.ComplexList {
+    protected terraformResource: cdktf.IInterpolatingParent;
+    protected terraformAttribute: string;
+    protected wrapsSet: boolean;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean);
+    /**
+    * @param index the index of the item to return
+    */
+    get(index: number): DataOciFunctionsFunctionsFunctionsOutputReference;
+}
+export interface DataOciFunctionsFunctionsFilter {
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#name DataOciFunctionsFunctions#name}
+    */
+    readonly name: string;
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#regex DataOciFunctionsFunctions#regex}
+    */
+    readonly regex?: boolean | cdktf.IResolvable;
+    /**
+    * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#values DataOciFunctionsFunctions#values}
+    */
+    readonly values: string[];
+}
+export declare function dataOciFunctionsFunctionsFilterToTerraform(struct?: DataOciFunctionsFunctionsFilter | cdktf.IResolvable): any;
+export declare function dataOciFunctionsFunctionsFilterToHclTerraform(struct?: DataOciFunctionsFunctionsFilter | cdktf.IResolvable): any;
+export declare class DataOciFunctionsFunctionsFilterOutputReference extends cdktf.ComplexObject {
+    private isEmptyObject;
+    private resolvableValue?;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean);
+    get internalValue(): DataOciFunctionsFunctionsFilter | cdktf.IResolvable | undefined;
+    set internalValue(value: DataOciFunctionsFunctionsFilter | cdktf.IResolvable | undefined);
+    private _name?;
+    get name(): string;
+    set name(value: string);
+    get nameInput(): string | undefined;
+    private _regex?;
+    get regex(): boolean | cdktf.IResolvable;
+    set regex(value: boolean | cdktf.IResolvable);
+    resetRegex(): void;
+    get regexInput(): boolean | cdktf.IResolvable | undefined;
+    private _values?;
+    get values(): string[];
+    set values(value: string[]);
+    get valuesInput(): string[] | undefined;
+}
+export declare class DataOciFunctionsFunctionsFilterList extends cdktf.ComplexList {
+    protected terraformResource: cdktf.IInterpolatingParent;
+    protected terraformAttribute: string;
+    protected wrapsSet: boolean;
+    internalValue?: DataOciFunctionsFunctionsFilter[] | cdktf.IResolvable;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource: cdktf.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean);
+    /**
+    * @param index the index of the item to return
+    */
+    get(index: number): DataOciFunctionsFunctionsFilterOutputReference;
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions oci_functions_functions}
+*/
+export declare class DataOciFunctionsFunctions extends cdktf.TerraformDataSource {
+    static readonly tfResourceType = "oci_functions_functions";
+    /**
+    * Generates CDKTF code for importing a DataOciFunctionsFunctions resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the DataOciFunctionsFunctions to import
+    * @param importFromId The id of the existing DataOciFunctionsFunctions that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the DataOciFunctionsFunctions to import is found
+    */
+    static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktf.TerraformProvider): cdktf.ImportableResource;
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/hashicorp/oci/5.47.0/docs/data-sources/functions_functions oci_functions_functions} Data Source
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options DataOciFunctionsFunctionsConfig
+    */
+    constructor(scope: Construct, id: string, config: DataOciFunctionsFunctionsConfig);
+    private _applicationId?;
+    get applicationId(): string;
+    set applicationId(value: string);
+    get applicationIdInput(): string | undefined;
+    private _displayName?;
+    get displayName(): string;
+    set displayName(value: string);
+    resetDisplayName(): void;
+    get displayNameInput(): string | undefined;
+    private _functions;
+    get functions(): DataOciFunctionsFunctionsFunctionsList;
+    private _id?;
+    get id(): string;
+    set id(value: string);
+    resetId(): void;
+    get idInput(): string | undefined;
+    private _state?;
+    get state(): string;
+    set state(value: string);
+    resetState(): void;
+    get stateInput(): string | undefined;
+    private _filter;
+    get filter(): DataOciFunctionsFunctionsFilterList;
+    putFilter(value: DataOciFunctionsFunctionsFilter[] | cdktf.IResolvable): void;
+    resetFilter(): void;
+    get filterInput(): cdktf.IResolvable | DataOciFunctionsFunctionsFilter[] | undefined;
+    protected synthesizeAttributes(): {
+        [name: string]: any;
+    };
+    protected synthesizeHclAttributes(): {
+        [name: string]: any;
+    };
+}