$ dart pub global activate serverpod_cli

$ serverpod

❯ serverpod 

Manage your serverpod app development

Usage: serverpod <command> [arguments]

Global options:
-h, --help              Print this usage information.
-q, --quiet             Suppress all serverpod cli output. Is overridden by  -v, --verbose.
-v, --verbose           Prints additional information useful for development. Overrides --q, --quiet.
-a, --[no-]analytics    Toggles if analytics data is sent to Serverpod.
                        (defaults to on)

Available commands:
  create                    Creates a new Serverpod project, specify project name (must be lowercase with no special characters).
  create-migration          Creates a migration from the last migration to the current state of the database.
  create-repair-migration   Repairs the database by comparing the target state to what is in the live database instead of comparing to
                            the latest migration.
  generate                  Generate code from yaml files for server and clients.
  language-server           Launches a serverpod language server communicating with JSON-RPC-2 intended to be used with a client
                            integrated in an IDE.
  version                   Prints the active version of the Serverpod CLI.

Run "serverpod help <command>" for more information about a command.

$ serverpod create mypod

$ cd mypod/mypod_server
$ docker compose up --build --detach

$ dart bin/main.dart --apply-migrations

$ cd mypod/mypod_flutter
$ flutter run -d chrome

# This is the configuration file for your local development environment. By
# default, it runs a single server on port 8080. To set up your server, you will
# need to add the name of the database you are connecting to and the user name.
# The password for the database is stored in the config/passwords.yaml.
#
# When running your server locally, the server ports are the same as the public
# facing ports.

# Configuration for the main API server.
apiServer:
  port: 8080
  publicHost: localhost
  publicPort: 8080
  publicScheme: http

# Configuration for the Insights server.
insightsServer:
  port: 8081
  publicHost: localhost
  publicPort: 8081
  publicScheme: http

# Configuration for the web server.
webServer:
  port: 8082
  publicHost: localhost
  publicPort: 8082
  publicScheme: http

# This is the database setup for your server.
database:
  host: localhost
  port: 8090
  name: mypod
  user: postgres

# This is the setup for Redis.
redis:
  enabled: false
  host: localhost
  port: 8091

# Use this file to store passwords to services that your server you use. When
# the server starts, the passwords will be automatically loaded and can be
# accessed from the `session.passwords` field. If you don't have access to a
# session object, passwords can also be accessed from
# `Serverpod.instance.passwords`. You can provide different passwords for
# different run configurations. If you want the same password for any
# configuration used, place it under `shared`.
#
# Note that this file should not be under version control. Store it in a safe
# place.

# Save passwords used across all configurations here.
shared:
  mySharedPassword: 'my password'

# These are passwords used when running the server locally in development mode
development:
  database: 'jBXWslvjYpfszBbFKS661o1MrY1esjVC'
  redis: 'ijH4ON9CCHtK9Cojnqivvym1zxHkwjig'

  # The service secret is used to communicate between servers and to access the
  # service protocol.
  serviceSecret: 'uVoVJ-cqnwc9Bn8gQG-ZLtYfgXGnMUu3'

# Passwords used in your staging environment if you use one. The default setup
# use a password for Redis.
staging:
  database: '3_5RPi7yVOSwSEhr8ecNftp1K4H0_7nL'
  serviceSecret: 'JgM8DPORU5OwOyG23_gdjhYuRLD6mk1J'

# Passwords used in production mode.
production:
  database: 'ReE97mCuS0QaxlXEy4hNMQYtE_Q1lxP4'
  serviceSecret: '0XpMqP4aybryFxm4N8V5ZXHcPFTHUXpP'

type: server

client_package_path: ../mypod_client

version: '3.7'

services:
  postgres:
    image: postgres:14.1
    ports:
      - '8090:5432'
    environment:
      POSTGRES_USER: postgres
      POSTGRES_DB: mypod
      POSTGRES_PASSWORD: "jBXWslvjYpfszBbFKS661o1MrY1esjVC"
    volumes:
      - mypod_data:/var/lib/postgresql/data
  redis:
    image: redis:6.2.6
    ports:
      - '8091:6379'
    command: redis-server --requirepass "ijH4ON9CCHtK9Cojnqivvym1zxHkwjig"
    environment:
      - REDIS_REPLICATION_MODE=master
volumes:
  mypod_data:

class ExampleEndpoint extends Endpoint {
  // You create methods in your endpoint which are accessible from the client by
  // creating a public method with `Session` as its first parameter.
  // `bool`, `int`, `double`, `String`, `UuidValue`, `Duration`, `DateTime`, `ByteData`,
  // and other serializable classes, exceptions and enums from your from your `protocol` directory.
  // The methods should return a typed future; the same types as for the parameters are
  // supported. The `session` object provides access to the database, logging,
  // passwords, and information about the request being made to the server.
  Future<String> hello(Session session, String name) async {
    return 'Hello $name';
  }

  Future<String> hello2(Session session, String name) async {
    return 'Hello $name';
  }
}

$ cd mypod/mypod_server
$ serverpod generate

class EndpointExample extends _i1.EndpointRef {
  EndpointExample(_i1.EndpointCaller caller) : super(caller);

  @override
  String get name => 'example';

  _i2.Future<String> hello(String name) => caller.callServerEndpoint<String>(
        'example',
        'hello',
        {'name': name},
      );

  _i2.Future<String> hello2(String name) => caller.callServerEndpoint<String>(
        'example',
        'hello2',
        {'name': name},
      );
}

  void _callHello2() async {
    try {
      final result = await client.example.hello2(_textEditingController.text);
      setState(() {
        _errorMessage = null;
        _resultMessage = result;
      });
    } catch (e) {
      setState(() {
        _errorMessage = '$e';
      });
    }
  }

...
  
  Padding(
              padding: const EdgeInsets.only(bottom: 16.0),
              child: ElevatedButton(
                onPressed: _callHello2,
                child: const Text('Send to Server'),
              ),
            ),

class: Note
table: note
fields:
  text: String

serverpod generate

import 'package:serverpod/server.dart';

import '../generated/protocol.dart';

class NotesEndpoint extends Endpoint {
  Future<List<Note>> getAllNotes(Session session) async {
    // By ordering by the id column, we always get the notes in the same order
    // and not in the order they were updated.
    return await Note.db.find(
      session,
      orderBy: (t) => t.id,
    );
  }

  Future<void> createNote(Session session, Note note) async {
    await Note.db.insertRow(session, note);
  }

  Future<void> deleteNote(Session session, Note note) async {
    await Note.db.deleteRow(session, note);
  }
}

$ serverpod create-migration

$ cd mypod/mypod_server
$ dart bin/main.dart --apply-migrations

dart bin/main.dart --apply-migrations

  void _callNoteCreate() async {
    try {
      await client.notes.createNote(Note(text: "this is example."));
      setState(() {
        _errorMessage = null;
        _resultMessage = "create send~";
      });
    } catch (e) {
      setState(() {
        _errorMessage = '$e';
      });
    }
  }

Padding(
              padding: const EdgeInsets.only(bottom: 16.0),
              child: ElevatedButton(
                onPressed: _callNoteCreate,
                child: const Text('Note Create Send To Server'),
              ),
            ),

$ cd mypod/mypod_flutter
$ flutter run -d chrome

FROM dart:3.2.5 AS build

WORKDIR /app
COPY . .

RUN dart pub get
RUN dart compile exe bin/main.dart -o bin/server

FROM alpine:latest

ENV runmode=production
ENV serverid=default
ENV logging=normal
ENV role=monolith

COPY --from=build /runtime/ /
COPY --from=build /app/bin/server server
COPY --from=build /app/config/ config/
COPY --from=build /app/web/ web/

EXPOSE 8080
EXPOSE 8081
EXPOSE 8082

ENTRYPOINT ./server --mode=$runmode --server-id=$serverid --logging=$logging --role=$role

$ cd mypod/mypod_server
$ docker build -t mypod_server:v1.0 .